for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

            raise VCSError("Given object should be FileNode object, not %s"

                % filenode.__class__)

    repo = filenode_new.changeset.repository

    old_raw_id = getattr(filenode_old.changeset, 'raw_id', repo.EMPTY_CHANGESET)

    new_raw_id = getattr(filenode_new.changeset, 'raw_id', repo.EMPTY_CHANGESET)

    vcs_gitdiff = repo.get_diff(old_raw_id, new_raw_id, filenode_new.path,

                                ignore_whitespace, context)

    return vcs_gitdiff

NEW_FILENODE = 1

DEL_FILENODE = 2

MOD_FILENODE = 3

RENAMED_FILENODE = 4

COPIED_FILENODE = 5

CHMOD_FILENODE = 6

BIN_FILENODE = 7

class DiffProcessor(object):

    """

    Give it a unified or git diff and it returns a list of the files that were

    mentioned in the diff together with a dict of meta information that

    can be used to render it in a HTML template.

    """

    _diff_git_re = re.compile('^diff --git', re.MULTILINE)

    _chunk_re = re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')

    _newline_marker = re.compile(r'^\\ No newline at end of file')

    _git_header_re = re.compile(r"""

        ^diff[ ]--git

            [ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

        (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

           ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

        (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%\n

           ^rename[ ]from[ ](?P<rename_from>.+)\n

           ^rename[ ]to[ ](?P<rename_to>.+)(?:\n|$))?

        (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?

        (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?

        (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)

            \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?

        (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?

        (?:^---[ ](a/(?P<a_file>.+?)|/dev/null)\t?(?:\n|$))?

        (?:^\+\+\+[ ](b/(?P<b_file>.+?)|/dev/null)\t?(?:\n|$))?

        (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?

        (?:^---[ ](a/(?P<a_file>.+?)|/dev/null)\t?(?:\n|$))?

        (?:^\+\+\+[ ](b/(?P<b_file>.+?)|/dev/null)\t?(?:\n|$))?

    """, re.VERBOSE | re.MULTILINE)

    # Used for inline highlighter word split, must match the substitutions in _escaper

    _token_re = re.compile(r'()(&amp;|&lt;|&gt;|<u>\t</u>|<u class="cr"></u>| <i></i>|\W+?)')

    _escape_re = re.compile(r'(&)|(<)|(>)|(\t)|(\r)|(?<=.)( \n| $)')

    def __init__(self, diff, vcs='hg', diff_limit=None, inline_diff=True):

        """

        :param diff:   a text in diff format

        :param vcs: type of version control hg or git

        :param diff_limit: define the size of diff that is considered "big"

            based on that parameter cut off will be triggered, set to None

            to show full diff

        """

        if not isinstance(diff, basestring):

            raise Exception('Diff must be a basestring got %s instead' % type(diff))

        self._diff = diff

        self.adds = 0

        self.removes = 0

        self.diff_limit = diff_limit

        self.limited_diff = False

        self.vcs = vcs

        self.parsed = self._parse_gitdiff(inline_diff=inline_diff)

    def _escaper(self, string):

        """

        """

        def substitute(m):

            groups = m.groups()

            if groups[0]:

                return '&'

            if groups[1]:

                return '<'

            if groups[2]:

                return '>'

            if groups[3]:

                return '<u>\t</u>'

            if groups[4]:

                return '<u class="cr"></u>'

            if groups[5]:

                return ' <i></i>'

            assert False

        return self._escape_re.sub(substitute, safe_unicode(string))

    def _highlight_inline_diff(self, old, new):

        """

        Highlight simple add/remove in two lines given as info dicts. They are

        modified in place and given markup with <del>/<ins>.

        """

        assert old['action'] == 'del'

        if self.vcs == 'git':

            match = self._git_header_re.match(diff_chunk)

        elif self.vcs == 'hg':

            match = self._hg_header_re.match(diff_chunk)

        if match is None:

            raise Exception('diff not recognized as valid %s diff' % self.vcs)

        meta_info = match.groupdict()

        rest = diff_chunk[match.end():]

        if rest and not rest.startswith('@') and not rest.startswith('literal ') and not rest.startswith('delta '):

            raise Exception('cannot parse %s diff header: %r followed by %r' % (self.vcs, diff_chunk[:match.end()], rest[:1000]))

        diff_lines = (self._escaper(m.group(0)) for m in re.finditer(r'.*\n|.+$', rest)) # don't split on \r as str.splitlines do

        return meta_info, diff_lines

    def _parse_gitdiff(self, inline_diff):

        """Parse self._diff and return a list of dicts with meta info and chunks for each file.

        Might set limited_diff.

        Optionally, do an extra pass and to extra markup of one-liner changes.

        """

        _files = [] # list of dicts with meta info and chunks

        starts = [m.start() for m in self._diff_git_re.finditer(self._diff)]

        starts.append(len(self._diff))

        for start, end in zip(starts, starts[1:]):

            head, diff_lines = self._get_header(buffer(self._diff, start, end - start))

            op = None

            stats = {

                'added': 0,

                'deleted': 0,

                'binary': False,

                'ops': {},

            }

            if head['deleted_file_mode']:

                op = 'D'

                stats['binary'] = True

                stats['ops'][DEL_FILENODE] = 'deleted file'

            elif head['new_file_mode']:

                op = 'A'

                stats['binary'] = True

                stats['ops'][NEW_FILENODE] = 'new file %s' % head['new_file_mode']

            else:  # modify operation, can be cp, rename, chmod

                # CHMOD

                if head['new_mode'] and head['old_mode']:

                    op = 'M'

                    stats['binary'] = True

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][COPIED_FILENODE] = ('file copied from %s to %s'

                                        % (head['copy_from'], head['copy_to']))

                # FALL BACK: detect missed old style add or remove

                if op is None:

                    if not head['a_file'] and head['b_file']:

                        op = 'A'

                        stats['binary'] = True

                        stats['ops'][NEW_FILENODE] = 'new file'

                    elif head['a_file'] and not head['b_file']:

                        op = 'D'

                        stats['binary'] = True

                        stats['ops'][DEL_FILENODE] = 'deleted file'

                # it's not ADD not DELETE

                if op is None:

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][MOD_FILENODE] = 'modified file'

            # a real non-binary diff

            if head['a_file'] or head['b_file']:

            else:  # Git binary patch (or empty diff)

                # Git binary patch

                if head['bin_patch']:

                    stats['ops'][BIN_FILENODE] = 'binary diff not shown'

                chunks = []

            if op == 'D' and chunks:

                # a way of seeing deleted content could perhaps be nice - but

                # not with the current UI

                chunks = []

            chunks.insert(0, [{

                'old_lineno': '',

                'new_lineno': '',

                'action':     'context',

                'line':       msg,

                } for _op, msg in stats['ops'].iteritems()

                  if _op not in [MOD_FILENODE]])

            _files.append({

                'old_filename':     head['a_path'],

                'filename':         head['b_path'],

                'old_revision':     head['a_blob_id'],

                'new_revision':     head['b_blob_id'],