~bzr-pqm/bzr/bzr.dev

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

 

"""Helper functions for DirState.

 

 

from bzrlib import cache_utf8, errors, osutils

from bzrlib.dirstate import DirState

 

 

# This is the Windows equivalent of ENOTDIR

cdef extern from *:

    ctypedef unsigned long size_t

 

    ctypedef int intptr_t

 

 

    object PyTuple_GetItem_void_object "PyTuple_GET_ITEM" (void* tpl, int index)

    object PyTuple_GET_ITEM(object tpl, Py_ssize_t index)

 

 

    char *PyString_AsString(object p)

    char *PyString_AsString_obj "PyString_AsString" (PyObject *string)

    # ??? memrchr is a GNU extension :(

    # void *memrchr(void *s, int c, size_t len)

 

    # memrchr seems to be a GNU extension, so we have to implement it ourselves

    cdef char *pos

    cdef char *start

        return None

    return <char*>found - <char*>_s

 

cdef object safe_string_from_size(char *s, Py_ssize_t size):

    if size < 0:

        raise AssertionError(

    return PyString_FromStringAndSize(s, size)

 

 

    """Is this pointer aligned to an integer size offset?

 

    :return: 1 if this pointer is aligned, 0 otherwise.

    return ((<intptr_t>ptr) & ((sizeof(int))-1)) == 0

 

 

    cdef unsigned char *cur1

    cdef unsigned char *cur2

    cdef unsigned char *end1

    return 0

 

 

    """Compare two paths directory by directory.

 

    This is equivalent to doing::

                        PyString_Size(path2))

 

 

    """Compare two paths based on what directory they are in.

 

    This generates a sort order, such that all children of a directory are

    if not PyString_CheckExact(path2):

        raise TypeError("'path2' must be a plain string, not %s: %r"

                        % (type(path2), path2))

    """Compare two paths by what directory they are in.

 

    """

    cdef char *dirname1

    cdef int dirname1_len

    return 1

 

 

    """Return the index where to insert path into paths.

 

    This uses a path-wise comparison so we get::

        cur = PyList_GetItem_object_void(paths, _mid)

        cur_cstr = PyString_AS_STRING_void(cur)

        cur_size = PyString_GET_SIZE_void(cur)

            _lo = _mid + 1

        else:

            _hi = _mid

    return _lo

 

 

    """Return the index where to insert path into paths.

 

    This uses a path-wise comparison so we get::

        cur = PyList_GetItem_object_void(paths, _mid)

        cur_cstr = PyString_AS_STRING_void(cur)

        cur_size = PyString_GET_SIZE_void(cur)

            _hi = _mid

        else:

            _lo = _mid + 1

    return _lo

 

 

    """Return the index where to insert dirname into the dirblocks.

 

    The return value idx is such that all directories blocks in dirblock[:idx]

        :param new_block: This is to let the caller know that it needs to

            create a new directory block to store the next entry.

        """

        cdef char *entry_size_cstr

        cdef unsigned long int entry_size

        cdef char* executable_cstr

        # Build up the key that will be used.

        # By using <object>(void *) Pyrex will automatically handle the

        # Py_INCREF that we need.

 

        # Parse all of the per-tree information. current has the information in

        # the same location as parent trees. The only difference is that 'info'

            executable_cstr = self.get_next(&cur_size)

            is_executable = (executable_cstr[0] == c'y')

            info = self.get_next_str()

                minikind,     # minikind

                fingerprint,  # fingerprint

                entry_size,   # size

        self.state._split_root_dirblock_into_contents()

 

 

    """Read in the dirblocks for the given DirState object.

 

    This is tightly bound to the DirState internal representation. It should be

    state._dirblock_state = DirState.IN_MEMORY_UNMODIFIED

 

 

    # in order of frequency:

    if S_ISREG(mode):

        return c"f"

    cdef char result[6*4] # 6 long ints

    cdef int *aliased

    aliased = <int *>result

    packed = PyString_FromStringAndSize(result, 6*4)

    return _encode(packed)[:-1]

 

    # _st mode of the compiled stat objects.

    cdef int minikind, saved_minikind

    cdef void * details

    minikind = minikind_from_mode(stat_value.st_mode)

    if 0 == minikind:

        return None

    # If we have gotten this far, that means that we need to actually

    # process this entry.

    link_or_sha1 = None

    if minikind == c'f':

        executable = self._is_executable(stat_value.st_mode,

                                         saved_executable)

            entry[1][0] = ('f', link_or_sha1, stat_value.st_size,

                           executable, packed_stat)

        else:

    elif minikind == c'd':

        entry[1][0] = ('d', '', 0, False, packed_stat)

        if saved_minikind != c'd':

            # This changed from something into a directory. Make sure we

                self._get_block_entry_index(entry[0][0], entry[0][1], 0)

            self._ensure_block(block_index, entry_index,

                               pathjoin(entry[0][0], entry[0][1]))

    elif minikind == c'l':

        link_or_sha1 = self._read_link(abspath, saved_link_or_sha1)

        if self._cutoff_time is None:

            self._sha_cutoff_time()

        else:

            entry[1][0] = ('l', '', stat_value.st_size,

                           False, DirState.NULLSTAT)

    return link_or_sha1

 

 

    """Convert a python string to a char."""

    return PyString_AsString(string)[0]

 

    raise KeyError(PyString_FromStringAndSize(_minikind, 1))

 

 

    """Return non-zero if minikind is in fltd"""

    return (minikind == c'f' or

            minikind == c'd' or

 

cdef class ProcessEntryC:

 

    cdef object old_dirname_to_file_id # dict

    cdef object new_dirname_to_file_id # dict

    cdef object last_source_parent

    cdef object last_target_parent

    cdef object use_filesystem_for_exec

    cdef object utf8_decode

    cdef readonly object searched_specific_files

    cdef object search_specific_files

    cdef object state

    # Current iteration variables:

    cdef object current_root

    cdef object current_block_list

    cdef object current_dir_info

    cdef object current_dir_list

    cdef int path_index

    cdef object root_dir_info

    cdef object bisect_left

    cdef object pathjoin

    cdef object fstat

    cdef object sha_file

 

    def __init__(self, include_unchanged, use_filesystem_for_exec,

        search_specific_files, state, source_index, target_index,

        want_unversioned, tree):

        self.old_dirname_to_file_id = {}

        self.new_dirname_to_file_id = {}

        # Using a list so that we can access the values and change them in

        # nested scope. Each one is [path, file_id, entry]

        self.last_source_parent = [None, None]

        self.last_target_parent = [None, None]

        self.use_filesystem_for_exec = use_filesystem_for_exec

        self.utf8_decode = cache_utf8._utf8_decode

        # for all search_indexs in each path at or under each element of

        self.searched_specific_files = set()

        self.search_specific_files = search_specific_files

        self.state = state

        self.current_root = None

        self.current_root_unicode = None

        self.current_block_pos = -1

        self.current_dir_info = None

        self.current_dir_list = None

        self.path_index = 0

        self.root_dir_info = None

        self.bisect_left = bisect.bisect_left

        self.pathjoin = osutils.pathjoin

        self.fstat = os.fstat

        self.sha_file = osutils.sha_file

 

    cdef _process_entry(self, entry, path_info):

        """Compare an entry and real disk to generate delta information.

 

        :param path_info: top_relpath, basename, kind, lstat, abspath for

            Basename is returned as a utf8 string because we expect this

            tuple will be ignored, and don't want to take the time to

            decode.

        """

        cdef char target_minikind

        cdef char source_minikind

            else:

                # add the source to the search path to find any children it

                # has.  TODO ? : only add if it is a container ?

                    self.search_specific_files.add(source_details[1])

                # generate the old path; this is needed for stating later

                # as well.

                old_path = source_details[1]

                    if source_minikind != c'f':

                        content_change = 1

                    else:

                    # Target details is updated at update_entry time

                    if self.use_filesystem_for_exec:

                        # We don't need S_ISREG here, because we are sure

                        content_change = 0

                    target_exec = False

                else:

            if source_minikind == c'd':

                if path is None:

                    old_path = path = self.pathjoin(old_dirname, old_basename)

                    file_id = entry[0][2]

                self.old_dirname_to_file_id[old_path] = file_id

            # parent id is the entry for the path in the target tree

                source_parent_id = self.last_source_parent[1]

            else:

                try:

                    source_parent_id = self.old_dirname_to_file_id[old_dirname]

                    source_parent_entry = self.state._get_entry(self.source_index,

                                                           path_utf8=old_dirname)

                    source_parent_id = source_parent_entry[0][2]

                    self.last_source_parent[0] = old_dirname

                    self.last_source_parent[1] = source_parent_id

            new_dirname = entry[0][0]

                target_parent_id = self.last_target_parent[1]

            else:

                try:

                    target_parent_id = self.new_dirname_to_file_id[new_dirname]

                    # TODO: We don't always need to do the lookup, because the

                    #       parent entry will be the same as the source entry.

                    target_parent_entry = self.state._get_entry(self.target_index,

                    self.last_target_parent[1] = target_parent_id

 

            source_exec = source_details[3]

                or source_parent_id != target_parent_id

                or old_basename != entry[0][1]

                or source_exec != target_exec

                if old_path is None:

                    path = self.pathjoin(old_dirname, old_basename)

                    old_path = path

                       (source_parent_id, target_parent_id),

                       (self.utf8_decode(old_basename)[0], self.utf8_decode(entry[0][1])[0]),

                       (source_kind, target_kind),

        elif source_minikind == c'a' and _versioned_minikind(target_minikind):

            # looks like a new file

            path = self.pathjoin(entry[0][0], entry[0][1])

                       (None, parent_id),

                       (None, self.utf8_decode(entry[0][1])[0]),

                       (None, path_info[2]),

            else:

                # Its a missing file, report it as such.

                return (entry[0][2],

                       (None, parent_id),

                       (None, self.utf8_decode(entry[0][1])[0]),

                       (None, None),

        elif _versioned_minikind(source_minikind) and target_minikind == c'a':

            # unversioned, possibly, or possibly not deleted: we dont care.

            # if its still on disk, *and* theres no other entry at this

                   (parent_id, None),

                   (self.utf8_decode(entry[0][1])[0], None),

                   (_minikind_to_kind(source_minikind), None),

        elif _versioned_minikind(source_minikind) and target_minikind == c'r':

            # a rename; could be a true rename, or a rename inherited from

            # a renamed parent. TODO: handle this efficiently. Its not

            # common case to rename dirs though, so a correct but slow

            # implementation will do.

                self.search_specific_files.add(target_details[1])

        elif ((source_minikind == c'r' or source_minikind == c'a') and

              (target_minikind == c'r' or target_minikind == c'a')):

            # neither of the selected trees contain this path,

                "source_minikind=%r, target_minikind=%r"

                % (source_minikind, target_minikind))

            ## import pdb;pdb.set_trace()

 

    def __iter__(self):

        return self

    def iter_changes(self):

        return self

 

        if (self.block_index < len(self.state._dirblocks) and

            osutils.is_inside(self.current_root, self.state._dirblocks[self.block_index][0])):

            self.current_block = self.state._dirblocks[self.block_index]

        else:

            self.current_block = None

            self.current_block_list = None

 

    def __next__(self):

        # Simple thunk to allow tail recursion without pyrex confusion

        cdef char * current_dirname_c, * current_blockname_c

        cdef int advance_entry, advance_path

        cdef int path_handled

        searched_specific_files = self.searched_specific_files

        # Are we walking a root?

        while self.root_entries_pos < self.root_entries_len:

            entry = self.root_entries[self.root_entries_pos]

            self.root_entries_pos = self.root_entries_pos + 1

        # Have we finished the prior root, or never started one ?

        if self.current_root is None:

            # TODO: the pending list should be lexically sorted?  the

            # interface doesn't require it.

            try:

                self.current_root = self.search_specific_files.pop()

                raise StopIteration()

            self.searched_specific_files.add(self.current_root)

            # process the entries for this containing directory: the rest will be

            # found by their parents recursively.

            self.root_entries = self.state._entries_for_path(self.current_root)

            self.root_entries_len = len(self.root_entries)

            self.root_abspath = self.tree.abspath(self.current_root_unicode)

            try:

                root_stat = os.lstat(self.root_abspath)

            while self.root_entries_pos < self.root_entries_len:

                entry = self.root_entries[self.root_entries_pos]

                self.root_entries_pos = self.root_entries_pos + 1

                    path_handled = -1

                        return result

            # handle unversioned specified paths:

            if self.want_unversioned and not path_handled and self.root_dir_info:

                      )

            # If we reach here, the outer flow continues, which enters into the

            # per-root setup logic.

            # setup iteration of this root:

            self.current_dir_list = None

            if self.root_dir_info and self.root_dir_info[2] == 'tree-reference':

                        #            and e.winerror == ERROR_DIRECTORY

                        try:

                            e_winerror = e.winerror

                            e_winerror = None

                        win_errors = (ERROR_DIRECTORY, ERROR_PATH_NOT_FOUND)

                        if (e.errno in win_errors or e_winerror in win_errors):

                    try:

                        self.current_dir_info = self.dir_iterator.next()

                        self.current_dir_list = self.current_dir_info[1]

                        self.current_dir_info = None

                else: #(dircmp > 0)

                    # We have a dirblock entry for this location, but there

                        self.current_block_pos = self.current_block_pos + 1

                        # entry referring to file not present on disk.

                        # advance the entry only, after processing.

                                return result