'Run the state machine on `input_lines`. Return results (a list).
Reset `self.line_offset` and `self.current_state`. Run the
beginning-of-file transition. Input one line at a time and check for a
matching transition. If a match is found, call the transition method
and possibly change the state. Store the context returned by the
transition method to be passed on to the next transition matched.
Accumulate the results returned by the transition methods in a list.
Run the end-of-file transition. Finally, return the accumulated
results.
Parameters:
- `input_lines`: a list of strings without newlines, or `StringList`.
- `input_offset`: the line offset of `input_lines` from the beginning
of the file.
- `context`: application-specific storage.
- `input_source`: name or path of source of `input_lines`.'

def run(self, input_lines, input_offset=0, context=None, input_source=None):

    self.runtime_init()
    if isinstance(input_lines, StringList):
        self.input_lines = input_lines
    else:
        self.input_lines = StringList(input_lines, source=input_source)
    self.input_offset = input_offset
    self.line_offset = (-1)
    self.current_state = self.initial_state
    if self.debug:
        print >>sys.stderr, ('\nStateMachine.run:    input_lines    (line_offset=%s):\n|    %s' % (self.line_offset, '\n|    '.join(self.input_lines)))
    transitions = None
    results = []
    state = self.get_state()
    try:
        if self.debug:
            print >>sys.stderr, '\nStateMachine.run:    bof    transition'
        (context, result) = state.bof(context)
        results.extend(result)
        while 1:
            try:
                try:
                    self.next_line()
                    if self.debug:
                        (source, offset) = self.input_lines.info(self.line_offset)
                        print >>sys.stderr, ('\nStateMachine.run:    line    (source=%r,    offset=%r):\n|    %s' % (source, offset, self.line))
                    (context, next_state, result) = self.check_line(context, state, transitions)
                except EOFError:
                    if self.debug:
                        print >>sys.stderr, ('\nStateMachine.run:    %s.eof    transition' % state.__class__.__name__)
                    result = state.eof(context)
                    results.extend(result)
                    break
                else:
                    results.extend(result)
            except TransitionCorrection as exception:
                self.previous_line()
                transitions = (exception.args[0],)
                if self.debug:
                    print >>sys.stderr, ('\nStateMachine.run:    TransitionCorrection    to    state    "%s",    transition    %s.' % (state.__class__.__name__, transitions[0]))
                continue
            except StateCorrection as exception:
                self.previous_line()
                next_state = exception.args[0]
                if (len(exception.args) == 1):
                    transitions = None
                else:
                    transitions = (exception.args[1],)
                if self.debug:
                    print >>sys.stderr, ('\nStateMachine.run:    StateCorrection    to    state    "%s",    transition    %s.' % (next_state, transitions[0]))
            else:
                transitions = None
            state = self.get_state(next_state)
    except:
        if self.debug:
            self.error()
        raise
    self.observers = []
    return results
