subversion/libsvn_wc/status.c - subversion - Git at Google

 /*
  * status.c: construct a status structure from an entry structure
  *
  * ====================================================================
  * Copyright (c) 2000-2002 CollabNet.  All rights reserved.
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
  * are also available at http://subversion.tigris.org/license-1.html.
  * If newer versions of this license are posted there, you may use a
  * newer version instead, at your option.
  *
  * This software consists of voluntary contributions made by many
  * individuals.  For exact contribution history, see the revision
  * history and logs, available at http://subversion.tigris.org/.
  * ====================================================================
  */


 #include <string.h>
 #include <apr_pools.h>
 #include <apr_file_io.h>
 #include <apr_hash.h>
 #include <apr_time.h>
 #include <apr_fnmatch.h>
 #include "svn_pools.h"
 #include "svn_types.h"
 #include "svn_string.h"
 #include "svn_error.h"
 #include "svn_path.h"
 #include "svn_wc.h"

 #include "wc.h"
 #include "props.h"


 static void add_default_ignores (apr_array_header_t *patterns)
 {
   static const char * const ignores[] =
   {
     "*.o", "*.lo", "*.la", "#*#", "*.rej", "*~", ".#*",
     /* what else? */
     NULL
   };
   int i;

   for (i = 0; ignores[i] != NULL; i++)
     {
       const char **ent = apr_array_push(patterns);
       *ent = ignores[i];
     }

 }


 /* Helper routine: add to a *PATTERNS list patterns from the value of
    the SVN_PROP_IGNORE property set on DIRPATH.  If there is no such
    property, or the property contains no patterns, do nothing.
    Otherwise, add to *PATTERNS a list of (const char *) patterns to
    match. */
 static svn_error_t *
 add_ignore_patterns (const char *dirpath,
                      apr_array_header_t *patterns,
                      apr_pool_t *pool)
 {
   const svn_string_t *value;

   /* Try to load the SVN_PROP_IGNORE property. */
   SVN_ERR (svn_wc_prop_get (&value, SVN_PROP_IGNORE, dirpath, pool));

   if (value != NULL)
     {
       static const char sep[3] = "\n\r";
       char *last;
       char *pats = apr_pstrdup (pool, value->data);
       char *p = apr_strtok (pats, sep, &last);

       while (p)
         {
           if (p[0] != '\0')
             {
               (*((const char **) apr_array_push (patterns))) = p;
             }
           p = apr_strtok (NULL, sep, &last);
         }
     }
   return SVN_NO_ERROR;
 }


 /* Fill in *STATUS for PATH, whose entry data is in ENTRY.  Allocate
    *STATUS in POOL.

    ENTRY may be null, for non-versioned entities.  In this case, we
    will assemble a special status structure item which implies a
    non-versioned thing.

    Else, ENTRY's pool must not be shorter-lived than STATUS's, since
    ENTRY will be stored directly, not copied.

    If GET_ALL is zero, and ENTRY is not locally modified, then *STATUS
    will be set to NULL.  If GET_ALL is non-zero, then *STATUS will be
    allocated and returned no matter what.

 */
 static svn_error_t *
 assemble_status (svn_wc_status_t **status,
                  svn_stringbuf_t *path,
                  svn_wc_entry_t *entry,
                  svn_boolean_t get_all,
                  svn_boolean_t strict,
                  apr_pool_t *pool)
 {
   svn_wc_status_t *stat;
   enum svn_node_kind path_kind;
   svn_boolean_t has_props;
   svn_boolean_t text_modified_p = FALSE;
   svn_boolean_t prop_modified_p = FALSE;
   svn_boolean_t locked_p = FALSE;

   /* Defaults for two main variables. */
   enum svn_wc_status_kind final_text_status = svn_wc_status_normal;
   enum svn_wc_status_kind final_prop_status = svn_wc_status_none;

   /* Check the path kind for PATH. */
   SVN_ERR( svn_io_check_path (path->data, &path_kind, pool));

   if (! entry)
     {
       /* return a blank structure. */
       stat = apr_pcalloc (pool, sizeof(*stat));
       stat->entry = NULL;
       stat->text_status = svn_wc_status_none;
       stat->prop_status = svn_wc_status_none;
       stat->repos_text_status = svn_wc_status_none;
       stat->repos_prop_status = svn_wc_status_none;
       stat->locked = FALSE;
       stat->copied = FALSE;

       /* If this path has no entry, but IS present on disk, it's
          unversioned. */
       if (path_kind != svn_node_none)
         stat->text_status = svn_wc_status_unversioned;

       /* If we're in strict mode and we encounter a path that doesn't
          exist in the wc, then we return an error*/
       if (strict && (path_kind == svn_node_none))
         return svn_error_createf (APR_ENOENT, 0, NULL, pool,
                                   "assemble_status: "
                                   "%s: No such file or directory",
                                   path->data);

       *status = stat;
       return SVN_NO_ERROR;
     }

   /* Implement predecence rules: */

   /* 1. Set the two main variables to "discovered" values first (M, C).
         Together, these two stati are of lowest precedence, and C has
         precedence over M. */

   /* Does the entry have props? */
   SVN_ERR (svn_wc__has_props (&has_props, path, pool));
   if (has_props)
     final_prop_status = svn_wc_status_normal;

   /* If the entry has a property file, see if it has local changes. */
   SVN_ERR (svn_wc_props_modified_p (&prop_modified_p, path, pool));

   /* If the entry is a file, check for textual modifications */
   if (entry->kind == svn_node_file)
     SVN_ERR (svn_wc_text_modified_p (&text_modified_p, path, pool));

   if (text_modified_p)
     final_text_status = svn_wc_status_modified;

   if (prop_modified_p)
     final_prop_status = svn_wc_status_modified;

   if (entry->prejfile || entry->conflict_old ||
       entry->conflict_new || entry->conflict_wrk)
     {
       svn_boolean_t text_conflict_p, prop_conflict_p;
       svn_stringbuf_t *parent_dir;

       if (entry->kind == svn_node_dir)
         parent_dir = path;
       else  /* non-directory, that's all we need to know */
         {
           parent_dir = svn_stringbuf_dup (path, pool);
           svn_path_remove_component (parent_dir);
         }

       SVN_ERR (svn_wc_conflicted_p (&text_conflict_p, &prop_conflict_p,
                                     parent_dir, entry, pool));

       if (text_conflict_p)
         final_text_status = svn_wc_status_conflicted;
       if (prop_conflict_p)
         final_prop_status = svn_wc_status_conflicted;
     }

   /* 2. Possibly overwrite the the text_status variable with
         "scheduled" states from the entry (A, D, R).  As a group,
         these states are of medium precedence.  They also override any
         C or M that may be in the prop_status field at this point.*/

   if (entry->schedule == svn_wc_schedule_add)
     {
       final_text_status = svn_wc_status_added;
       final_prop_status = svn_wc_status_none;
     }

   else if (entry->schedule == svn_wc_schedule_replace)
     {
       final_text_status = svn_wc_status_replaced;
       final_prop_status = svn_wc_status_none;
     }

   else if (entry->schedule == svn_wc_schedule_delete)
     {
       final_text_status = svn_wc_status_deleted;
       final_prop_status = svn_wc_status_none;
     }


   /* 3. Highest precedence: check to see if file or dir is just
         missing.  This overrides every possible state *except*
         deletion.  (If something is deleted or scheduled for it, we
         don't care if the working file exists.)  */

   if ((path_kind == svn_node_none)
       && (final_text_status != svn_wc_status_deleted))
     final_text_status = svn_wc_status_absent;


   /* 4. Check for locked directory. */

   if (entry->kind == svn_node_dir)
     SVN_ERR (svn_wc_locked (&locked_p, path, pool));


   /* 5. Easy out:  unless we're fetching -every- entry, don't bother
      to allocate a struct for an uninteresting entry. */

   if (! get_all)
     if (((final_text_status == svn_wc_status_none)
          || (final_text_status == svn_wc_status_normal))
         && ((final_prop_status == svn_wc_status_none)
             || (final_prop_status == svn_wc_status_normal))
         && (! locked_p))
       {
         *status = NULL;
         return SVN_NO_ERROR;
       }


   /* 6. Build and return a status structure. */

   stat = apr_pcalloc (pool, sizeof(**status));
   stat->entry = svn_wc_entry_dup (entry, pool);
   stat->text_status = final_text_status;
   stat->prop_status = final_prop_status;
   stat->repos_text_status = svn_wc_status_none;   /* default */
   stat->repos_prop_status = svn_wc_status_none;   /* default */
   stat->locked = locked_p;
   stat->copied = entry->copied;

   *status = stat;

   return SVN_NO_ERROR;
 }


 /* Given an ENTRY object representing PATH, build a status structure
    and store it in STATUSHASH.  */
 static svn_error_t *
 add_status_structure (apr_hash_t *statushash,
                       svn_stringbuf_t *path,
                       svn_wc_entry_t *entry,
                       svn_boolean_t get_all,
                       svn_boolean_t strict,
                       apr_pool_t *pool)
 {
   svn_wc_status_t *statstruct;

   SVN_ERR (assemble_status (&statstruct, path, entry,
                             get_all, strict, pool));
   if (statstruct)
     apr_hash_set (statushash, path->data, path->len, statstruct);

   return SVN_NO_ERROR;
 }


 /* Add all items that are NOT in ENTRIES (which is a list of PATH's
    versioned things) to the STATUSHASH as unversioned items,
    allocating everything in POOL. */
 static svn_error_t *
 add_unversioned_items (svn_stringbuf_t *path,
                        apr_hash_t *entries,
                        apr_hash_t *statushash,
                        apr_pool_t *pool)
 {
   apr_pool_t *subpool = svn_pool_create (pool);
   apr_hash_t *dirents;
   apr_hash_index_t *hi;
   apr_array_header_t *patterns;

   /* Read PATH's dirents. */
   SVN_ERR (svn_io_get_dirents (&dirents, path, subpool));

   /* Try to load any '.svnignore' file that may be present. */
   patterns = apr_array_make (subpool, 1, sizeof(const char *));
   add_default_ignores (patterns);
   SVN_ERR (add_ignore_patterns (path->data, patterns, subpool));

   /* Add empty status structures for each of the unversioned things. */
   for (hi = apr_hash_first (subpool, dirents); hi; hi = apr_hash_next (hi))
     {
       const void *key;
       apr_ssize_t klen;
       void *val;
       const char *keystring;
       int i;
       int ignore_me;
       svn_stringbuf_t *printable_path;

       apr_hash_this (hi, &key, &klen, &val);
       keystring = (const char *) key;

       /* If the dirent isn't in `.svn/entries'... */
       if (apr_hash_get (entries, key, klen))
         continue;

       /* and we're not looking at .svn... */
       if (! strcmp (keystring, SVN_WC_ADM_DIR_NAME))
         continue;

       ignore_me = 0;

       /* See if any of the ignore patterns we have matches our
          keystring. */
       for (i = 0; i < patterns->nelts; i++)
         {
           const char *pat = (((const char **) (patterns)->elts))[i];

           /* Try to match current_entry_name to pat. */
           if (APR_SUCCESS == apr_fnmatch (pat, keystring, FNM_PERIOD))
             {
               ignore_me = 1;
               break;
             }
         }

       /* If we aren't ignoring it, add a status structure for this
          dirent. */
       if (! ignore_me)
         {
           /* Reset our base string... */
           printable_path = svn_stringbuf_dup (path, pool);
           /* ...and append the current entry. */
           svn_path_add_component_nts (printable_path, keystring);

           /* Add this item to the status hash. */
           SVN_ERR (add_status_structure (statushash,
                                          printable_path,
                                          NULL, /* no entry */
                                          FALSE,
                                          FALSE,
                                          pool));
         }
     }

   svn_pool_destroy (subpool);

   return SVN_NO_ERROR;
 }


 svn_error_t *
 svn_wc_status (svn_wc_status_t **status,
                svn_stringbuf_t *path,
                apr_pool_t *pool)
 {
   svn_wc_status_t *s;
   svn_wc_entry_t *entry = NULL;

   /* Don't check for error;  PATH may be unversioned, or nonexistent
      (in the case of 'svn st -u' being told about as-yet-unknnown
      paths), and either condition will cause svn_wc_entry to return an
      error.  If this routine returns error, then a NULL entry will be
      passed to assemble_status() below, which is fine -- a blank
      status structure will be returned with either 'unversioned' or
      'absent' status filled in. */
   svn_wc_entry (&entry, path, pool);

   SVN_ERR (assemble_status (&s, path, entry, TRUE, FALSE, pool));
   *status = s;
   return SVN_NO_ERROR;
 }


 svn_error_t *
 svn_wc_statuses (apr_hash_t *statushash,
                  svn_stringbuf_t *path,
                  svn_boolean_t descend,
                  svn_boolean_t get_all,
                  svn_boolean_t strict,
                  apr_pool_t *pool)
 {
   enum svn_node_kind kind;
   svn_wc_entry_t *entry;

   /* Is PATH a directory or file? */
   SVN_ERR (svn_io_check_path (path->data, &kind, pool));

   /* kff todo: this has to deal with the case of a type-changing edit,
      i.e., someone removed a file under vc and replaced it with a dir,
      or vice versa.  In such a case, when you ask for the status, you
      should get mostly information about the now-vanished entity, plus
      some information about what happened to it.  The same situation
      is handled in entries.c:svn_wc_entry. */

   /* Read the appropriate entries file */

   /* If path points to just one file, or at least to just one
      non-directory, store just one status structure in the
      STATUSHASH and return. */
   if ((kind == svn_node_file) || (kind == svn_node_none))
     {
       /* Get the entry for this file. Place it into the specified pool since
          we're going to return it in statushash. */
       SVN_ERR (svn_wc_entry (&entry, path, pool));

       /* Convert the entry into a status structure, store in the hash.

          ### Notice that because we're getting one specific file,
          we're ignoring the GET_ALL flag and unconditionally fetching
          the status structure. */
       SVN_ERR (add_status_structure (statushash, path, entry,
                                      TRUE, strict, pool));
     }


   /* Fill the hash with a status structure for *each* entry in PATH */
   else if (kind == svn_node_dir)
     {
       apr_hash_t *entries;
       apr_hash_index_t *hi;

       /* Load entries file for the directory into the requested pool. */
       SVN_ERR (svn_wc_entries_read (&entries, path, pool));

       /* Add the unversioned items to the status output. */
       SVN_ERR (add_unversioned_items (path, entries, statushash, pool));

       /* Loop over entries hash */
       for (hi = apr_hash_first (pool, entries); hi; hi = apr_hash_next (hi))
         {
           const void *key;
           void *val;
           const char *basename;
           apr_ssize_t keylen;

           /* Put fullpath into the request pool since it becomes a key
              in the output statushash hash table. */
           svn_stringbuf_t *fullpath = svn_stringbuf_dup (path, pool);

           /* Get the next dirent */
           apr_hash_this (hi, &key, &keylen, &val);
           basename = (const char *) key;
           if (strcmp (basename, SVN_WC_ENTRY_THIS_DIR) != 0)
             {
               svn_path_add_component_nts (fullpath, basename);
             }

           entry = (svn_wc_entry_t *) val;

           SVN_ERR (svn_io_check_path (fullpath->data, &kind, pool));

           /* In deciding whether or not to descend, we use the actual
              kind of the entity, not the kind claimed by the entries
              file.  The two are usually the same, but where they are
              not, its usually because some directory got moved, and
              one would still want a status report on its contents.
              kff todo: However, must handle mixed working copies.
              What if the subdir is not under revision control, or is
              from another repository? */

           /* Do *not* store THIS_DIR in the statushash, unless this
              path has never been seen before.  We don't want to add
              the path key twice. */
           if (! strcmp (basename, SVN_WC_ENTRY_THIS_DIR))
             {
               svn_wc_status_t *s = apr_hash_get (statushash,
                                                  fullpath->data,
                                                  fullpath->len);
               if (! s)
                 SVN_ERR (add_status_structure (statushash, fullpath,
                                                entry, get_all,
                                                strict, pool));
             }
           else
             {
               if (kind == svn_node_dir && descend)
                 {
                   /* Directory entries are incomplete.  We must get
                      their full entry from their own THIS_DIR entry.
                      svn_wc_entry does this for us if it can.  */
                   svn_wc_entry_t *subdir;

                   SVN_ERR (svn_wc_entry (&subdir, fullpath, pool));
                   SVN_ERR (add_status_structure (statushash, fullpath,
                                                  subdir, get_all,
                                                  strict, pool));
                   SVN_ERR (svn_wc_statuses (statushash, fullpath,
                                             descend, get_all, strict, pool));
                 }
               else if ((kind == svn_node_file) || (kind == svn_node_none))
                 {
                   /* File entries are ... just fine! */
                   SVN_ERR (add_status_structure (statushash, fullpath,
                                                  entry, get_all,
                                                  strict, pool));
                 }
             }
         }
     }

   return SVN_NO_ERROR;
 }


 /*
  * local variables:
  * eval: (load-file "../../tools/dev/svn-dev.el")
  * end:
  */
	/*
	* status.c: construct a status structure from an entry structure
	*
	* ====================================================================
	* Copyright (c) 2000-2002 CollabNet. All rights reserved.
	*
	* This software is licensed as described in the file COPYING, which
	* you should have received as part of this distribution. The terms
	* are also available at http://subversion.tigris.org/license-1.html.
	* If newer versions of this license are posted there, you may use a
	* newer version instead, at your option.
	*
	* This software consists of voluntary contributions made by many
	* individuals. For exact contribution history, see the revision
	* history and logs, available at http://subversion.tigris.org/.
	* ====================================================================
	*/



	#include <string.h>
	#include <apr_pools.h>
	#include <apr_file_io.h>
	#include <apr_hash.h>
	#include <apr_time.h>
	#include <apr_fnmatch.h>
	#include "svn_pools.h"
	#include "svn_types.h"
	#include "svn_string.h"
	#include "svn_error.h"
	#include "svn_path.h"
	#include "svn_wc.h"

	#include "wc.h"
	#include "props.h"


	static void add_default_ignores (apr_array_header_t *patterns)
	{
	static const char * const ignores[] =
	{
	".o", ".lo", ".la", "##", ".rej", "~", ".#*",
	/* what else? */
	NULL
	};
	int i;

	for (i = 0; ignores[i] != NULL; i++)
	{
	const char **ent = apr_array_push(patterns);
	*ent = ignores[i];
	}

	}


	/* Helper routine: add to a *PATTERNS list patterns from the value of
	the SVN_PROP_IGNORE property set on DIRPATH. If there is no such
	property, or the property contains no patterns, do nothing.
	Otherwise, add to PATTERNS a list of (const char ) patterns to
	match. */
	static svn_error_t *
	add_ignore_patterns (const char *dirpath,
	apr_array_header_t *patterns,
	apr_pool_t *pool)
	{
	const svn_string_t *value;

	/* Try to load the SVN_PROP_IGNORE property. */
	SVN_ERR (svn_wc_prop_get (&value, SVN_PROP_IGNORE, dirpath, pool));

	if (value != NULL)
	{
	static const char sep[3] = "\n\r";
	char *last;
	char *pats = apr_pstrdup (pool, value->data);
	char *p = apr_strtok (pats, sep, &last);

	while (p)
	{
	if (p[0] != '\0')
	{
	(((const char *) apr_array_push (patterns))) = p;
	}
	p = apr_strtok (NULL, sep, &last);
	}
	}
	return SVN_NO_ERROR;
	}



	/* Fill in *STATUS for PATH, whose entry data is in ENTRY. Allocate
	*STATUS in POOL.

	ENTRY may be null, for non-versioned entities. In this case, we
	will assemble a special status structure item which implies a
	non-versioned thing.

	Else, ENTRY's pool must not be shorter-lived than STATUS's, since
	ENTRY will be stored directly, not copied.

	If GET_ALL is zero, and ENTRY is not locally modified, then *STATUS
	will be set to NULL. If GET_ALL is non-zero, then *STATUS will be
	allocated and returned no matter what.

	*/
	static svn_error_t *
	assemble_status (svn_wc_status_t **status,
	svn_stringbuf_t *path,
	svn_wc_entry_t *entry,
	svn_boolean_t get_all,
	svn_boolean_t strict,
	apr_pool_t *pool)
	{
	svn_wc_status_t *stat;
	enum svn_node_kind path_kind;
	svn_boolean_t has_props;
	svn_boolean_t text_modified_p = FALSE;
	svn_boolean_t prop_modified_p = FALSE;
	svn_boolean_t locked_p = FALSE;

	/* Defaults for two main variables. */
	enum svn_wc_status_kind final_text_status = svn_wc_status_normal;
	enum svn_wc_status_kind final_prop_status = svn_wc_status_none;

	/* Check the path kind for PATH. */
	SVN_ERR( svn_io_check_path (path->data, &path_kind, pool));

	if (! entry)
	{
	/* return a blank structure. */
	stat = apr_pcalloc (pool, sizeof(*stat));
	stat->entry = NULL;
	stat->text_status = svn_wc_status_none;
	stat->prop_status = svn_wc_status_none;
	stat->repos_text_status = svn_wc_status_none;
	stat->repos_prop_status = svn_wc_status_none;
	stat->locked = FALSE;
	stat->copied = FALSE;

	/* If this path has no entry, but IS present on disk, it's
	unversioned. */
	if (path_kind != svn_node_none)
	stat->text_status = svn_wc_status_unversioned;

	/* If we're in strict mode and we encounter a path that doesn't
	exist in the wc, then we return an error*/
	if (strict && (path_kind == svn_node_none))
	return svn_error_createf (APR_ENOENT, 0, NULL, pool,
	"assemble_status: "
	"%s: No such file or directory",
	path->data);

	*status = stat;
	return SVN_NO_ERROR;
	}

	/* Implement predecence rules: */

	/* 1. Set the two main variables to "discovered" values first (M, C).
	Together, these two stati are of lowest precedence, and C has
	precedence over M. */

	/* Does the entry have props? */
	SVN_ERR (svn_wc__has_props (&has_props, path, pool));
	if (has_props)
	final_prop_status = svn_wc_status_normal;

	/* If the entry has a property file, see if it has local changes. */
	SVN_ERR (svn_wc_props_modified_p (&prop_modified_p, path, pool));

	/* If the entry is a file, check for textual modifications */
	if (entry->kind == svn_node_file)
	SVN_ERR (svn_wc_text_modified_p (&text_modified_p, path, pool));

	if (text_modified_p)
	final_text_status = svn_wc_status_modified;

	if (prop_modified_p)
	final_prop_status = svn_wc_status_modified;

	if (entry->prejfile \|\| entry->conflict_old \|\|
	entry->conflict_new \|\| entry->conflict_wrk)
	{
	svn_boolean_t text_conflict_p, prop_conflict_p;
	svn_stringbuf_t *parent_dir;

	if (entry->kind == svn_node_dir)
	parent_dir = path;
	else /* non-directory, that's all we need to know */
	{
	parent_dir = svn_stringbuf_dup (path, pool);
	svn_path_remove_component (parent_dir);
	}

	SVN_ERR (svn_wc_conflicted_p (&text_conflict_p, &prop_conflict_p,
	parent_dir, entry, pool));

	if (text_conflict_p)
	final_text_status = svn_wc_status_conflicted;
	if (prop_conflict_p)
	final_prop_status = svn_wc_status_conflicted;
	}

	/* 2. Possibly overwrite the the text_status variable with
	"scheduled" states from the entry (A, D, R). As a group,
	these states are of medium precedence. They also override any
	C or M that may be in the prop_status field at this point.*/

	if (entry->schedule == svn_wc_schedule_add)
	{
	final_text_status = svn_wc_status_added;
	final_prop_status = svn_wc_status_none;
	}

	else if (entry->schedule == svn_wc_schedule_replace)
	{
	final_text_status = svn_wc_status_replaced;
	final_prop_status = svn_wc_status_none;
	}

	else if (entry->schedule == svn_wc_schedule_delete)
	{
	final_text_status = svn_wc_status_deleted;
	final_prop_status = svn_wc_status_none;
	}


	/* 3. Highest precedence: check to see if file or dir is just
	missing. This overrides every possible state except
	deletion. (If something is deleted or scheduled for it, we
	don't care if the working file exists.) */

	if ((path_kind == svn_node_none)
	&& (final_text_status != svn_wc_status_deleted))
	final_text_status = svn_wc_status_absent;


	/* 4. Check for locked directory. */

	if (entry->kind == svn_node_dir)
	SVN_ERR (svn_wc_locked (&locked_p, path, pool));


	/* 5. Easy out: unless we're fetching -every- entry, don't bother
	to allocate a struct for an uninteresting entry. */

	if (! get_all)
	if (((final_text_status == svn_wc_status_none)
	\|\| (final_text_status == svn_wc_status_normal))
	&& ((final_prop_status == svn_wc_status_none)
	\|\| (final_prop_status == svn_wc_status_normal))
	&& (! locked_p))
	{
	*status = NULL;
	return SVN_NO_ERROR;
	}


	/* 6. Build and return a status structure. */

	stat = apr_pcalloc (pool, sizeof(**status));
	stat->entry = svn_wc_entry_dup (entry, pool);
	stat->text_status = final_text_status;
	stat->prop_status = final_prop_status;
	stat->repos_text_status = svn_wc_status_none; /* default */
	stat->repos_prop_status = svn_wc_status_none; /* default */
	stat->locked = locked_p;
	stat->copied = entry->copied;

	*status = stat;

	return SVN_NO_ERROR;
	}


	/* Given an ENTRY object representing PATH, build a status structure
	and store it in STATUSHASH. */
	static svn_error_t *
	add_status_structure (apr_hash_t *statushash,
	svn_stringbuf_t *path,
	svn_wc_entry_t *entry,
	svn_boolean_t get_all,
	svn_boolean_t strict,
	apr_pool_t *pool)
	{
	svn_wc_status_t *statstruct;

	SVN_ERR (assemble_status (&statstruct, path, entry,
	get_all, strict, pool));
	if (statstruct)
	apr_hash_set (statushash, path->data, path->len, statstruct);

	return SVN_NO_ERROR;
	}


	/* Add all items that are NOT in ENTRIES (which is a list of PATH's
	versioned things) to the STATUSHASH as unversioned items,
	allocating everything in POOL. */
	static svn_error_t *
	add_unversioned_items (svn_stringbuf_t *path,
	apr_hash_t *entries,
	apr_hash_t *statushash,
	apr_pool_t *pool)
	{
	apr_pool_t *subpool = svn_pool_create (pool);
	apr_hash_t *dirents;
	apr_hash_index_t *hi;
	apr_array_header_t *patterns;

	/* Read PATH's dirents. */
	SVN_ERR (svn_io_get_dirents (&dirents, path, subpool));

	/* Try to load any '.svnignore' file that may be present. */
	patterns = apr_array_make (subpool, 1, sizeof(const char *));
	add_default_ignores (patterns);
	SVN_ERR (add_ignore_patterns (path->data, patterns, subpool));

	/* Add empty status structures for each of the unversioned things. */
	for (hi = apr_hash_first (subpool, dirents); hi; hi = apr_hash_next (hi))
	{
	const void *key;
	apr_ssize_t klen;
	void *val;
	const char *keystring;
	int i;
	int ignore_me;
	svn_stringbuf_t *printable_path;

	apr_hash_this (hi, &key, &klen, &val);
	keystring = (const char *) key;

	/* If the dirent isn't in `.svn/entries'... */
	if (apr_hash_get (entries, key, klen))
	continue;

	/* and we're not looking at .svn... */
	if (! strcmp (keystring, SVN_WC_ADM_DIR_NAME))
	continue;

	ignore_me = 0;

	/* See if any of the ignore patterns we have matches our
	keystring. */
	for (i = 0; i < patterns->nelts; i++)
	{
	const char pat = (((const char *) (patterns)->elts))[i];

	/* Try to match current_entry_name to pat. */
	if (APR_SUCCESS == apr_fnmatch (pat, keystring, FNM_PERIOD))
	{
	ignore_me = 1;
	break;
	}
	}

	/* If we aren't ignoring it, add a status structure for this
	dirent. */
	if (! ignore_me)
	{
	/* Reset our base string... */
	printable_path = svn_stringbuf_dup (path, pool);
	/* ...and append the current entry. */
	svn_path_add_component_nts (printable_path, keystring);

	/* Add this item to the status hash. */
	SVN_ERR (add_status_structure (statushash,
	printable_path,
	NULL, /* no entry */
	FALSE,
	FALSE,
	pool));
	}
	}

	svn_pool_destroy (subpool);

	return SVN_NO_ERROR;
	}


	svn_error_t *
	svn_wc_status (svn_wc_status_t **status,
	svn_stringbuf_t *path,
	apr_pool_t *pool)
	{
	svn_wc_status_t *s;
	svn_wc_entry_t *entry = NULL;

	/* Don't check for error; PATH may be unversioned, or nonexistent
	(in the case of 'svn st -u' being told about as-yet-unknnown
	paths), and either condition will cause svn_wc_entry to return an
	error. If this routine returns error, then a NULL entry will be
	passed to assemble_status() below, which is fine -- a blank
	status structure will be returned with either 'unversioned' or
	'absent' status filled in. */
	svn_wc_entry (&entry, path, pool);

	SVN_ERR (assemble_status (&s, path, entry, TRUE, FALSE, pool));
	*status = s;
	return SVN_NO_ERROR;
	}



	svn_error_t *
	svn_wc_statuses (apr_hash_t *statushash,
	svn_stringbuf_t *path,
	svn_boolean_t descend,
	svn_boolean_t get_all,
	svn_boolean_t strict,
	apr_pool_t *pool)
	{
	enum svn_node_kind kind;
	svn_wc_entry_t *entry;

	/* Is PATH a directory or file? */
	SVN_ERR (svn_io_check_path (path->data, &kind, pool));

	/* kff todo: this has to deal with the case of a type-changing edit,
	i.e., someone removed a file under vc and replaced it with a dir,
	or vice versa. In such a case, when you ask for the status, you
	should get mostly information about the now-vanished entity, plus
	some information about what happened to it. The same situation
	is handled in entries.c:svn_wc_entry. */

	/* Read the appropriate entries file */

	/* If path points to just one file, or at least to just one
	non-directory, store just one status structure in the
	STATUSHASH and return. */
	if ((kind == svn_node_file) \|\| (kind == svn_node_none))
	{
	/* Get the entry for this file. Place it into the specified pool since
	we're going to return it in statushash. */
	SVN_ERR (svn_wc_entry (&entry, path, pool));

	/* Convert the entry into a status structure, store in the hash.

	### Notice that because we're getting one specific file,
	we're ignoring the GET_ALL flag and unconditionally fetching
	the status structure. */
	SVN_ERR (add_status_structure (statushash, path, entry,
	TRUE, strict, pool));
	}


	/* Fill the hash with a status structure for each entry in PATH */
	else if (kind == svn_node_dir)
	{
	apr_hash_t *entries;
	apr_hash_index_t *hi;

	/* Load entries file for the directory into the requested pool. */
	SVN_ERR (svn_wc_entries_read (&entries, path, pool));

	/* Add the unversioned items to the status output. */
	SVN_ERR (add_unversioned_items (path, entries, statushash, pool));

	/* Loop over entries hash */
	for (hi = apr_hash_first (pool, entries); hi; hi = apr_hash_next (hi))
	{
	const void *key;
	void *val;
	const char *basename;
	apr_ssize_t keylen;

	/* Put fullpath into the request pool since it becomes a key
	in the output statushash hash table. */
	svn_stringbuf_t *fullpath = svn_stringbuf_dup (path, pool);

	/* Get the next dirent */
	apr_hash_this (hi, &key, &keylen, &val);
	basename = (const char *) key;
	if (strcmp (basename, SVN_WC_ENTRY_THIS_DIR) != 0)
	{
	svn_path_add_component_nts (fullpath, basename);
	}

	entry = (svn_wc_entry_t *) val;

	SVN_ERR (svn_io_check_path (fullpath->data, &kind, pool));

	/* In deciding whether or not to descend, we use the actual
	kind of the entity, not the kind claimed by the entries
	file. The two are usually the same, but where they are
	not, its usually because some directory got moved, and
	one would still want a status report on its contents.
	kff todo: However, must handle mixed working copies.
	What if the subdir is not under revision control, or is
	from another repository? */

	/* Do not store THIS_DIR in the statushash, unless this
	path has never been seen before. We don't want to add
	the path key twice. */
	if (! strcmp (basename, SVN_WC_ENTRY_THIS_DIR))
	{
	svn_wc_status_t *s = apr_hash_get (statushash,
	fullpath->data,
	fullpath->len);
	if (! s)
	SVN_ERR (add_status_structure (statushash, fullpath,
	entry, get_all,
	strict, pool));
	}
	else
	{
	if (kind == svn_node_dir && descend)
	{
	/* Directory entries are incomplete. We must get
	their full entry from their own THIS_DIR entry.
	svn_wc_entry does this for us if it can. */
	svn_wc_entry_t *subdir;

	SVN_ERR (svn_wc_entry (&subdir, fullpath, pool));
	SVN_ERR (add_status_structure (statushash, fullpath,
	subdir, get_all,
	strict, pool));
	SVN_ERR (svn_wc_statuses (statushash, fullpath,
	descend, get_all, strict, pool));
	}
	else if ((kind == svn_node_file) \|\| (kind == svn_node_none))
	{
	/* File entries are ... just fine! */
	SVN_ERR (add_status_structure (statushash, fullpath,
	entry, get_all,
	strict, pool));
	}
	}
	}
	}

	return SVN_NO_ERROR;
	}





	/*
	* local variables:
	* eval: (load-file "../../tools/dev/svn-dev.el")
	* end:
	*/