fs_skels.c

subversion-1.4.5.tar.gz 配置svn的源码

    default:
      return skel_err("transaction");
    }


  /* COPIES */
  copies_skel = svn_fs_base__make_empty_list(pool);
  if (transaction->copies && transaction->copies->nelts)
    {
      int i;
      for (i = transaction->copies->nelts - 1; i >= 0; i--)
        {
          svn_fs_base__prepend(svn_fs_base__str_atom
                               (APR_ARRAY_IDX(transaction->copies, i,
                                              const char *), pool),
                               copies_skel);
        }
    }
  svn_fs_base__prepend(copies_skel, skel);

  /* PROPLIST */
  SVN_ERR(svn_fs_base__unparse_proplist_skel(&proplist_skel,
                                             transaction->proplist, pool));
  svn_fs_base__prepend(proplist_skel, skel);

  /* REVISION or BASE-ID */
  if (transaction->kind == transaction_kind_committed)
    {
      /* Committed transactions have a revision number... */
      svn_fs_base__prepend(svn_fs_base__str_atom
                           (apr_psprintf(pool, "%ld",
                                         transaction->revision), pool),
                           skel);
    }
  else
    {
      /* ...where other transactions have a base node revision ID. */
      id_str = svn_fs_base__id_unparse(transaction->base_id, pool);
      svn_fs_base__prepend(svn_fs_base__mem_atom(id_str->data, id_str->len,
                                                 pool), skel);
    }

  /* ROOT-ID */
  id_str = svn_fs_base__id_unparse(transaction->root_id, pool);
  svn_fs_base__prepend(svn_fs_base__mem_atom(id_str->data, id_str->len,
                                             pool), skel);

  /* KIND (see above) */
  svn_fs_base__prepend(header_skel, skel);

  /* Validate and return the skel. */
  if (! is_valid_transaction_skel(skel, &kind))
    return skel_err("transaction");
  if (kind != transaction->kind)
    return skel_err("transaction");
  *skel_p = skel;
  return SVN_NO_ERROR;
}


svn_error_t *
svn_fs_base__unparse_representation_skel(skel_t **skel_p,
                                         const representation_t *rep,
                                         apr_pool_t *pool)
{
  skel_t *skel = svn_fs_base__make_empty_list(pool);
  skel_t *header_skel = svn_fs_base__make_empty_list(pool);

  /** Some parts of the header are common to all representations; do
      those parts first. **/

  /* CHECKSUM */
  {
    skel_t *checksum_skel = svn_fs_base__make_empty_list(pool);
    svn_fs_base__prepend(svn_fs_base__mem_atom
                         (rep->checksum, APR_MD5_DIGESTSIZE, pool),
                         checksum_skel);
    svn_fs_base__prepend(svn_fs_base__str_atom("md5", pool), checksum_skel);
    svn_fs_base__prepend(checksum_skel, header_skel);
  }

  /* TXN */
  if (rep->txn_id)
    svn_fs_base__prepend(svn_fs_base__str_atom(rep->txn_id, pool),
                         header_skel);
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), header_skel);

  /** Do the kind-specific stuff. **/

  if (rep->kind == rep_kind_fulltext)
    {
      /*** Fulltext Representation. ***/

      /* STRING-KEY */
      if ((! rep->contents.fulltext.string_key)
          || (! *rep->contents.fulltext.string_key))
        svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);
      else
        svn_fs_base__prepend(svn_fs_base__str_atom
                             (rep->contents.fulltext.string_key, pool), skel);

      /* "fulltext" */
      svn_fs_base__prepend(svn_fs_base__str_atom("fulltext", pool),
                           header_skel);

      /* header */
      svn_fs_base__prepend(header_skel, skel);
    }
  else if (rep->kind == rep_kind_delta)
    {
      /*** Delta Representation. ***/
      int i;
      apr_array_header_t *chunks = rep->contents.delta.chunks;

      /* Loop backwards through the windows, creating and prepending skels. */
      for (i = chunks->nelts; i > 0; i--)
        {
          skel_t *window_skel = svn_fs_base__make_empty_list(pool);
          skel_t *chunk_skel = svn_fs_base__make_empty_list(pool);
          skel_t *diff_skel = svn_fs_base__make_empty_list(pool);
          const char *size_str, *offset_str, *version_str;
          rep_delta_chunk_t *chunk =
            (((rep_delta_chunk_t **) chunks->elts)[i - 1]);

          /* OFFSET */
          offset_str = apr_psprintf(pool, "%" SVN_FILESIZE_T_FMT,
                                    chunk->offset);

          /* SIZE */
          size_str = apr_psprintf(pool, "%" APR_SIZE_T_FMT, chunk->size);

          /* VERSION */
          version_str = apr_psprintf(pool, "%d", chunk->version);

          /* DIFF */
          if ((! chunk->string_key) || (! *chunk->string_key))
            svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool),
                                 diff_skel);
          else
            svn_fs_base__prepend(svn_fs_base__str_atom(chunk->string_key,
                                                       pool), diff_skel);
          svn_fs_base__prepend(svn_fs_base__str_atom(version_str, pool),
                               diff_skel);
          svn_fs_base__prepend(svn_fs_base__str_atom("svndiff", pool),
                               diff_skel);

          /* REP-KEY */
          if ((! chunk->rep_key) || (! *(chunk->rep_key)))
            svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool),
                                 window_skel);
          else
            svn_fs_base__prepend(svn_fs_base__str_atom(chunk->rep_key,
                                                       pool),
                                 window_skel);
          svn_fs_base__prepend(svn_fs_base__str_atom(size_str, pool),
                               window_skel);
          svn_fs_base__prepend(diff_skel, window_skel);

          /* window header. */
          svn_fs_base__prepend(window_skel, chunk_skel);
          svn_fs_base__prepend(svn_fs_base__str_atom(offset_str, pool),
                               chunk_skel);

          /* Add this window item to the main skel. */
          svn_fs_base__prepend(chunk_skel, skel);
        }

      /* "delta" */
      svn_fs_base__prepend(svn_fs_base__str_atom("delta", pool),
                           header_skel);

      /* header */
      svn_fs_base__prepend(header_skel, skel);
    }
  else /* unknown kind */
    abort();

  /* Validate and return the skel. */
  if (! is_valid_representation_skel(skel))
    return skel_err("representation");
  *skel_p = skel;
  return SVN_NO_ERROR;
}


svn_error_t *
svn_fs_base__unparse_node_revision_skel(skel_t **skel_p,
                                        const node_revision_t *noderev,
                                        apr_pool_t *pool)
{
  skel_t *skel;
  skel_t *header_skel;

  /* Create the skel. */
  skel = svn_fs_base__make_empty_list(pool);
  header_skel = svn_fs_base__make_empty_list(pool);

  /* PREDECESSOR-COUNT */
  if (noderev->predecessor_count != -1)
    {
      const char *count_str = apr_psprintf(pool, "%d",
                                           noderev->predecessor_count);
      svn_fs_base__prepend(svn_fs_base__str_atom(count_str, pool),
                           header_skel);
    }

  /* PREDECESSOR-ID */
  if (noderev->predecessor_id)
    {
      svn_string_t *id_str = svn_fs_base__id_unparse(noderev->predecessor_id,
                                                     pool);
      svn_fs_base__prepend(svn_fs_base__mem_atom(id_str->data, id_str->len,
                                                 pool),
                           header_skel);
    }
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), header_skel);

  /* CREATED-PATH */
  svn_fs_base__prepend(svn_fs_base__str_atom(noderev->created_path, pool),
                       header_skel);

  /* KIND */
  if (noderev->kind == svn_node_file)
    svn_fs_base__prepend(svn_fs_base__str_atom("file", pool), header_skel);
  else if (noderev->kind == svn_node_dir)
    svn_fs_base__prepend(svn_fs_base__str_atom("dir", pool), header_skel);
  else
    abort();

  /* ### do we really need to check *node->FOO_key ? if a key doesn't
     ### exist, then the field should be NULL ...  */

  /* EDIT-DATA-KEY (optional) */
  if ((noderev->edit_key) && (*noderev->edit_key))
    svn_fs_base__prepend(svn_fs_base__str_atom(noderev->edit_key, pool),
                         skel);

  /* DATA-KEY */
  if ((noderev->data_key) && (*noderev->data_key))
    svn_fs_base__prepend(svn_fs_base__str_atom(noderev->data_key, pool),
                         skel);
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);

  /* PROP-KEY */
  if ((noderev->prop_key) && (*noderev->prop_key))
    svn_fs_base__prepend(svn_fs_base__str_atom(noderev->prop_key, pool),
                         skel);
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);

  /* HEADER */
  svn_fs_base__prepend(header_skel, skel);

  /* Validate and return the skel. */
  if (! is_valid_node_revision_skel(skel))
    return skel_err("node-revision");
  *skel_p = skel;
  return SVN_NO_ERROR;
}


svn_error_t *
svn_fs_base__unparse_copy_skel(skel_t **skel_p,
                               const copy_t *copy,
                               apr_pool_t *pool)
{
  skel_t *skel;
  svn_string_t *tmp_str;

  /* Create the skel. */
  skel = svn_fs_base__make_empty_list(pool);

  /* DST-NODE-ID */
  tmp_str = svn_fs_base__id_unparse(copy->dst_noderev_id, pool);
  svn_fs_base__prepend(svn_fs_base__mem_atom(tmp_str->data, tmp_str->len,
                                             pool), skel);

  /* SRC-TXN-ID */
  if ((copy->src_txn_id) && (*copy->src_txn_id))
    svn_fs_base__prepend(svn_fs_base__str_atom(copy->src_txn_id, pool),
                         skel);
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);

  /* SRC-PATH */
  if ((copy->src_path) && (*copy->src_path))
    svn_fs_base__prepend(svn_fs_base__str_atom(copy->src_path, pool), skel);
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);

  /* "copy" */
  if (copy->kind == copy_kind_real)
    svn_fs_base__prepend(svn_fs_base__str_atom("copy", pool), skel);
  else
    svn_fs_base__prepend(svn_fs_base__str_atom("soft-copy", pool), skel);

  /* Validate and return the skel. */
  if (! is_valid_copy_skel(skel))
    return skel_err("copy");
  *skel_p = skel;
  return SVN_NO_ERROR;
}


svn_error_t *
svn_fs_base__unparse_entries_skel(skel_t **skel_p,
                                  apr_hash_t *entries,
                                  apr_pool_t *pool)
{
  skel_t *skel = svn_fs_base__make_empty_list(pool);
  apr_hash_index_t *hi;

  /* Create the skel. */
  if (entries)
    {
      /* Loop over hash entries */
      for (hi = apr_hash_first(pool, entries); hi; hi = apr_hash_next(hi))
        {
          const void *key;
          void *val;
          apr_ssize_t klen;
          svn_fs_id_t *value;
          svn_string_t *id_str;
          skel_t *entry_skel = svn_fs_base__make_empty_list(pool);

          apr_hash_this(hi, &key, &klen, &val);
          value = val;

          /* VALUE */
          id_str = svn_fs_base__id_unparse(value, pool);
          svn_fs_base__prepend(svn_fs_base__mem_atom(id_str->data,
                                                     id_str->len, pool),
                               entry_skel);

          /* NAME */
          svn_fs_base__prepend(svn_fs_base__mem_atom(key, klen, pool),
                               entry_skel);

          /* Add entry to the entries skel. */
          svn_fs_base__prepend(entry_skel, skel);
        }
    }

  /* Return the skel. */
  *skel_p = skel;
  return SVN_NO_ERROR;
}


svn_error_t *
svn_fs_base__unparse_change_skel(skel_t **skel_p,
                                 const change_t *change,
                                 apr_pool_t *pool)
{
  skel_t *skel;
  svn_string_t *tmp_str;
  svn_fs_path_change_kind_t kind;

  /* Create the skel. */
  skel = svn_fs_base__make_empty_list(pool);

  /* PROP-MOD */
  if (change->prop_mod)
    svn_fs_base__prepend(svn_fs_base__str_atom("1", pool), skel);
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);

  /* TEXT-MOD */
  if (change->text_mod)
    svn_fs_base__prepend(svn_fs_base__str_atom("1", pool), skel);
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);

  /* KIND */
  switch (change->kind)
    {
    case svn_fs_path_change_reset:
      svn_fs_base__prepend(svn_fs_base__str_atom("reset", pool), skel);
      break;
    case svn_fs_path_change_add:
      svn_fs_base__prepend(svn_fs_base__str_atom("add", pool), skel);
      break;
    case svn_fs_path_change_delete:
      svn_fs_base__prepend(svn_fs_base__str_atom("delete", pool), skel);
      break;
    case svn_fs_path_change_replace:
      svn_fs_base__prepend(svn_fs_base__str_atom("replace", pool), skel);
      break;
    case svn_fs_path_change_modify:
    default:
      svn_fs_base__prepend(svn_fs_base__str_atom("modify", pool), skel);
      break;
    }

  /* NODE-REV-ID */
  if (change->noderev_id)
    {
      tmp_str = svn_fs_base__id_unparse(change->noderev_id, pool);
      svn_fs_base__prepend(svn_fs_base__mem_atom(tmp_str->data,
                                                 tmp_str->len, pool),
                           skel);
    }
  else
    {
      svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);
    }

  /* PATH */
  svn_fs_base__prepend(svn_fs_base__str_atom(change->path, pool), skel);

  /* "change" */
  svn_fs_base__prepend(svn_fs_base__str_atom("change", pool), skel);

  /* Validate and return the skel. */
  if (! is_valid_change_skel(skel, &kind))
    return skel_err("change");
  if (kind != change->kind)
    return skel_err("change");
  *skel_p = skel;
  return SVN_NO_ERROR;
}


svn_error_t *
svn_fs_base__unparse_lock_skel(skel_t **skel_p,
                               const svn_lock_t *lock,
                               apr_pool_t *pool)
{
  skel_t *skel;

  /* Create the skel. */
  skel = svn_fs_base__make_empty_list(pool);

  /* EXP-DATE is optional.  If not present, just use an empty atom. */
  if (lock->expiration_date)
    svn_fs_base__prepend 
      (svn_fs_base__str_atom
       (svn_time_to_cstring(lock->expiration_date, pool), pool), skel);
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);

  /* CREATION-DATE */
  svn_fs_base__prepend 
    (svn_fs_base__str_atom
     (svn_time_to_cstring(lock->creation_date, pool), pool), skel);

  /* XML_P */
  if (lock->is_dav_comment)
    svn_fs_base__prepend(svn_fs_base__str_atom("1", pool), skel);
  else
    svn_fs_base__prepend(svn_fs_base__str_atom("0", pool), skel);

  /* COMMENT */
  if (lock->comment)
    svn_fs_base__prepend(svn_fs_base__str_atom(lock->comment, pool), skel);
  else
    svn_fs_base__prepend(svn_fs_base__mem_atom(NULL, 0, pool), skel);

  /* OWNER */
  svn_fs_base__prepend(svn_fs_base__str_atom(lock->owner, pool), skel);
  
  /* LOCK-TOKEN */
  svn_fs_base__prepend(svn_fs_base__str_atom(lock->token, pool), skel);

  /* PATH */
  svn_fs_base__prepend(svn_fs_base__str_atom(lock->path, pool), skel);

  /* "lock" */
  svn_fs_base__prepend(svn_fs_base__str_atom("lock", pool), skel);

  /* Validate and return the skel. */
  if (! is_valid_lock_skel(skel))
    return skel_err("lock");

  *skel_p = skel;
  return SVN_NO_ERROR;
}