Alien-SVN
33 results

 view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/ctypes-python/csvn/repos.py  view on Meta::CPAN 

           adding a slash if necessary."""
        pool = Pool()
        return RepositoryURI(svn_path_join(self, uri, pool))

    def dirname(self):
        """Get the parent directory of this URI"""
        pool = Pool()
        return RepositoryURI(svn_path_dirname(self, pool))

    def relative_path(self, uri, encoded=True):
        """Convert the supplied URI to a decoded path, relative to me."""
        pool = Pool()
        if not encoded:
            uri = svn_path_uri_encode(uri, pool)
        child_path = svn_path_is_child(self, uri, pool) or uri
        return str(svn_path_uri_decode(child_path, pool))

    def longest_ancestor(self, uri):
        """Get the longest ancestor of this URI and another URI"""
        pool = Pool()
        return RepositoryURI(svn_path_get_longest_ancestor(self, uri, pool))

src/subversion/subversion/include/private/svn_fspath.h  view on Meta::CPAN 

 */
char *
svn_fspath__get_longest_ancestor(const char *fspath1,
                                 const char *fspath2,
                                 apr_pool_t *result_pool);




/** A faux fspath API used by the DAV modules to help us distinguish
 * between real URI-decoded fspaths and URI-encoded URL path-portions.
 */
#define svn_urlpath__basename             svn_fspath__basename
#define svn_urlpath__dirname              svn_fspath__dirname
#define svn_urlpath__get_longest_ancestor svn_fspath__get_longest_ancestor
#define svn_urlpath__is_canonical         svn_fspath__is_canonical
#define svn_urlpath__is_root              svn_fspath__is_root
#define svn_urlpath__join                 svn_fspath__join
#define svn_urlpath__skip_ancestor        svn_fspath__skip_ancestor
#define svn_urlpath__split                svn_fspath__split

src/subversion/subversion/include/svn_base64.h  view on Meta::CPAN 

/** Return a writable generic stream which will encode binary data in
 * base64 format and write the encoded data to @a output.  Be sure to
 * close the stream when done writing in order to squeeze out the last
 * bit of encoded data.  The stream is allocated in @a pool.
 */
svn_stream_t *
svn_base64_encode(svn_stream_t *output,
                  apr_pool_t *pool);

/** Return a writable generic stream which will decode base64-encoded
 * data and write the decoded data to @a output.  The stream is allocated
 * in @a pool.
 */
svn_stream_t *
svn_base64_decode(svn_stream_t *output,
                  apr_pool_t *pool);


/** Encode an @c svn_stringbuf_t into base64.
 *
 * A simple interface for encoding base64 data assuming we have all of

src/subversion/subversion/include/svn_dirent_uri.h  view on Meta::CPAN 

 * Allocate the result in @a result_pool.
 *
 * @since New in 1.7.
 */
char *
svn_relpath_dirname(const char *relpath,
                    apr_pool_t *result_pool);


/** Divide the canonicalized @a uri into a uri @a *dirpath and a
 * (URI-decoded) relpath @a *base_name.
 *
 * If @a dirpath or @a base_name is NULL, then don't set that one.
 *
 * Either @a dirpath or @a base_name may be @a uri's own address, but they
 * may not both be the same address, or the results are undefined.
 *
 * If @a uri has two or more components, the separator between @a dirpath
 * and @a base_name is not included in either of the new names.
 *
 * Examples:

src/subversion/subversion/include/svn_dirent_uri.h  view on Meta::CPAN 

 * Allocate the result in @a result_pool.
 *
 * @since New in 1.7.
 */
void
svn_uri_split(const char **dirpath,
              const char **base_name,
              const char *uri,
              apr_pool_t *result_pool);

/** Get the (URI-decoded) basename of the specified canonicalized @a
 * uri.  The basename is defined as the last component of the uri.  If
 * the @a uri is root, return "".  The returned value will have no
 * slashes in it.
 *
 * Example: svn_uri_basename("http://server/foo/bar") -> "bar"
 *
 * Allocate the result in @a result_pool.
 *
 * @since New in 1.7.
 */

src/subversion/subversion/include/svn_dirent_uri.h  view on Meta::CPAN 

 * @a parent_relpath, or just "" if @a parent_relpath is equal to
 * @a child_relpath. If @a child_relpath is not below @a parent_relpath,
 * return NULL.
 *
 * @since New in 1.7.
 */
const char *
svn_relpath_skip_ancestor(const char *parent_relpath,
                          const char *child_relpath);

/** Return the URI-decoded relative path of @a child_uri that is below
 * @a parent_uri, or just "" if @a parent_uri is equal to @a child_uri. If
 * @a child_uri is not below @a parent_uri, return NULL.
 *
 * Allocate the result in @a result_pool.
 *
 * @since New in 1.7.
 */
const char *
svn_uri_skip_ancestor(const char *parent_uri,
                      const char *child_uri,

src/subversion/subversion/include/svn_dirent_uri.h  view on Meta::CPAN 

/** Find the common prefix of the canonicalized uris in @a targets
 * (an array of <tt>const char *</tt>'s), and remove redundant uris if @a
 * remove_redundancies is TRUE.
 *
 *   - Set @a *pcommon to the common base uri of all of the targets.
 *     If the targets have no common prefix (e.g. "http://srv1/file"
 *     and "http://srv2/file"), set @a *pcommon to the empty
 *     string.
 *
 *   - If @a pcondensed_targets is non-NULL, set @a *pcondensed_targets
 *     to an array of URI-decoded targets relative to @a *pcommon, and
 *     if @a remove_redundancies is TRUE, omit any uris that are
 *     descendants of another uri in @a targets.  If *pcommon is
 *     empty, @a *pcondensed_targets will contain absolute uris;
 *     redundancies can still be removed.  If @a pcondensed_targets is
 *     NULL, leave it alone.
 *
 * Else if there is exactly one target, then
 *
 *   - Set @a *pcommon to that target, and
 *

src/subversion/subversion/include/svn_path.h  view on Meta::CPAN 

/** Return @c TRUE iff @a path is URI-safe, @c FALSE otherwise. */
svn_boolean_t
svn_path_is_uri_safe(const char *path);

/** Return a URI-encoded copy of @a path, allocated in @a pool.  (@a
    path can be an arbitrary UTF-8 string and does not have to be a
    canonical path.) */
const char *
svn_path_uri_encode(const char *path, apr_pool_t *pool);

/** Return a URI-decoded copy of @a path, allocated in @a pool. */
const char *
svn_path_uri_decode(const char *path, apr_pool_t *pool);

/** Extend @a url by @a component, URI-encoding that @a component
 * before adding it to the @a url; return the new @a url, allocated in
 * @a pool.  If @a component is @c NULL, just return a copy of @a url,
 * allocated in @a pool.
 *
 * @a component need not be a single path segment, but if it contains
 * multiple segments, they must be separated by '/'.  @a component

src/subversion/subversion/include/svn_quoprint.h  view on Meta::CPAN 

/** Return a writable generic stream which will encode binary data in
 * quoted-printable format and write the encoded data to @a output.  Be
 * sure to close the stream when done writing in order to squeeze out
 * the last bit of encoded data.
 */
svn_stream_t *
svn_quoprint_encode(svn_stream_t *output,
                    apr_pool_t *pool);

/** Return a writable generic stream which will decode binary data in
 * quoted-printable format and write the decoded data to @a output.  Be
 * sure to close the stream when done writing in order to squeeze out
 * the last bit of encoded data.
 */
svn_stream_t *
svn_quoprint_decode(svn_stream_t *output,
                    apr_pool_t *pool);


/** Simpler interface for encoding quoted-printable data assuming we have all
 * of it present at once.  The returned string will be allocated from @a pool.

src/subversion/subversion/include/svn_ra.h  view on Meta::CPAN 

svn_error_t *
svn_ra_get_session_url(svn_ra_session_t *ra_session,
                       const char **url,
                       apr_pool_t *pool);


/** Convert @a url into a path relative to the session URL of @a ra_session,
 * setting @a *rel_path to that value.  If @a url is not
 * a child of the session URL, return @c SVN_ERR_RA_ILLEGAL_URL.
 *
 * The returned path is uri decoded to allow using it with the ra or other
 * apis as a valid relpath.
 *
 * @since New in 1.7.
 */
svn_error_t *
svn_ra_get_path_relative_to_session(svn_ra_session_t *ra_session,
                                    const char **rel_path,
                                    const char *url,
                                    apr_pool_t *pool);

/** Convert @a url into a path relative to the repository root URL of
 * the repository with which @a ra_session is associated, setting @a
 * *rel_path to that value.  If @a url is not a child of repository
 * root URL, return @c SVN_ERR_RA_ILLEGAL_URL.
 *
 * The returned path is uri decoded to allow using it with the ra or other
 * apis as a valid relpath.
 *
 * @since New in 1.7.
 */
svn_error_t *
svn_ra_get_path_relative_to_root(svn_ra_session_t *ra_session,
                                 const char **rel_path,
                                 const char *url,
                                 apr_pool_t *pool);

src/subversion/subversion/include/svn_repos.h  view on Meta::CPAN 

/* ---------------------------------------------------------------*/

/* Making commits. */

/**
 * Return an @a editor and @a edit_baton to commit changes to the
 * filesystem of @a repos, beginning at location 'rev:@a base_path',
 * where "rev" is the argument given to open_root().
 *
 * @a repos is a previously opened repository.  @a repos_url is the
 * decoded URL to the base of the repository, and is used to check
 * copyfrom paths.  copyfrom paths passed to the editor must be full,
 * URI-encoded, URLs.  @a txn is a filesystem transaction object to use
 * during the commit, or @c NULL to indicate that this function should
 * create (and fully manage) a new transaction.
 *
 * Store the contents of @a revprop_table, a hash mapping <tt>const
 * char *</tt> property names to #svn_string_t values, as properties
 * of the commit transaction, including author and log message if
 * present.
 *

src/subversion/subversion/include/svn_repos.h  view on Meta::CPAN 

 * (Note that prior to Subversion 1.6, @a commit_callback cannot be NULL; if
 * you don't need a callback, pass a dummy function.)
 *
 * Calling @a (*editor)->abort_edit aborts the commit, and will also
 * abort the commit transaction unless @a txn was supplied (not @c
 * NULL).  Callers who supply their own transactions are responsible
 * for cleaning them up (either by committing them, or aborting them).
 *
 * @since New in 1.5.
 *
 * @note Yes, @a repos_url is a <em>decoded</em> URL.  We realize
 * that's sorta wonky.  Sorry about that.
 */
svn_error_t *
svn_repos_get_commit_editor5(const svn_delta_editor_t **editor,
                             void **edit_baton,
                             svn_repos_t *repos,
                             svn_fs_txn_t *txn,
                             const char *repos_url,
                             const char *base_path,
                             apr_hash_t *revprop_table,

src/subversion/subversion/libsvn_client/commit.c  view on Meta::CPAN 


      /* Append this error to the chain. */
      svn_error_compose(err, bump_err);
    }

  return err;
}

/* For all lock tokens in ALL_TOKENS for URLs under BASE_URL, add them
   to a new hashtable allocated in POOL.  *RESULT is set to point to this
   new hash table.  *RESULT will be keyed on const char * URI-decoded paths
   relative to BASE_URL.  The lock tokens will not be duplicated. */
static svn_error_t *
collect_lock_tokens(apr_hash_t **result,
                    apr_hash_t *all_tokens,
                    const char *base_url,
                    apr_pool_t *pool)
{
  apr_hash_index_t *hi;

  *result = apr_hash_make(pool);

src/subversion/subversion/libsvn_client/commit_util.c  view on Meta::CPAN 

  struct item_commit_baton cb_baton;
  apr_array_header_t *paths =
    apr_array_make(scratch_pool, commit_items->nelts, sizeof(const char *));

  /* Ditto for the checksums. */
  if (sha1_checksums)
    *sha1_checksums = apr_hash_make(result_pool);

  /* Build a hash from our COMMIT_ITEMS array, keyed on the
     relative paths (which come from the item URLs).  And
     keep an array of those decoded paths, too.  */
  for (i = 0; i < commit_items->nelts; i++)
    {
      svn_client_commit_item3_t *item =
        APR_ARRAY_IDX(commit_items, i, svn_client_commit_item3_t *);
      const char *path = item->session_relpath;
      svn_hash_sets(items_hash, path, item);
      APR_ARRAY_PUSH(paths, const char *) = path;
    }

  /* Setup the callback baton. */

src/subversion/subversion/libsvn_delta/svndiff.c  view on Meta::CPAN 

     not transmit the whole svndiff data stream, you will want this to
     be FALSE. */
  svn_boolean_t error_on_early_close;

  /* svndiff version in use by delta.  */
  unsigned char version;
};


/* Decode an svndiff-encoded integer into *VAL and return a pointer to
   the byte after the integer.  The bytes to be decoded live in the
   range [P..END-1].  If these bytes do not contain a whole encoded
   integer, return NULL; in this case *VAL is undefined.

   See the comment for encode_int() earlier in this file for more detail on
   the encoding format.  */
static const unsigned char *
decode_file_offset(svn_filesize_t *val,
                   const unsigned char *p,
                   const unsigned char *end)
{

src/subversion/subversion/libsvn_delta/svndiff.c  view on Meta::CPAN 

  return NULL;
}

/* Decode the possibly-zlib compressed string of length INLEN that is in
   IN, into OUT.  We expect an integer is prepended to IN that specifies
   the original size, and that if encoded size == original size, that the
   remaining data is not compressed.
   In that case, we will simply return pointer into IN as data pointer for
   OUT, COPYLESS_ALLOWED has been set.  The, the caller is expected not to
   modify the contents of OUT.
   An error is returned if the decoded length exceeds the given LIMIT.
 */
static svn_error_t *
zlib_decode(const unsigned char *in, apr_size_t inLen, svn_stringbuf_t *out,
            apr_size_t limit)
{
  apr_size_t len;
  const unsigned char *oldplace = in;

  /* First thing in the string is the original length.  */
  in = decode_size(&len, in, in + inLen);

src/subversion/subversion/libsvn_delta/svndiff.c  view on Meta::CPAN 

  apr_size_t tpos = 0, npos = 0;

  while (p < end)
    {
      p = decode_instruction(&op, p, end);

      /* Detect any malformed operations from the instruction stream. */
      if (p == NULL)
        return svn_error_createf
          (SVN_ERR_SVNDIFF_INVALID_OPS, NULL,
           _("Invalid diff stream: insn %d cannot be decoded"), n);
      else if (op.length == 0)
        return svn_error_createf
          (SVN_ERR_SVNDIFF_INVALID_OPS, NULL,
           _("Invalid diff stream: insn %d has length zero"), n);
      else if (op.length > tview_len - tpos)
        return svn_error_createf
          (SVN_ERR_SVNDIFF_INVALID_OPS, NULL,
           _("Invalid diff stream: insn %d overflows the target view"), n);

      switch (op.action_code)

src/subversion/subversion/libsvn_ra_local/ra_local.h  view on Meta::CPAN 

/** Structures **/

/* A baton which represents a single ra_local session. */
typedef struct svn_ra_local__session_baton_t
{
  /* The user accessing the repository. */
  const char *username;

  /* The URL of the session, split into two components. */
  const char *repos_url;
  svn_stringbuf_t *fs_path;  /* URI-decoded, always with a leading slash. */

  /* A repository object. */
  svn_repos_t *repos;

  /* The filesystem object associated with REPOS above (for
     convenience). */
  svn_fs_t *fs;

  /* The UUID associated with REPOS above (cached) */
  const char *uuid;

src/subversion/subversion/libsvn_ra_serf/log.c  view on Meta::CPAN 

    TRUE, { "?node-kind", "?text-mods", "?prop-mods", NULL }, TRUE },

  { ITEM, S_, "modified-path", MODIFIED_PATH,
    TRUE, { "?node-kind", "?text-mods", "?prop-mods", NULL }, TRUE },

  { 0 }
};


/* Store CDATA into REVPROPS, associated with PROPNAME. If ENCODING is not
   NULL, then it must base "base64" and CDATA will be decoded first.

   NOTE: PROPNAME must live longer than REVPROPS.  */
static svn_error_t *
collect_revprop(apr_hash_t *revprops,
                const char *propname,
                const svn_string_t *cdata,
                const char *encoding)
{
  apr_pool_t *result_pool = apr_hash_pool_get(revprops);
  const svn_string_t *decoded;

  if (encoding)
    {
      /* Check for a known encoding type.  This is easy -- there's
         only one.  */
      if (strcmp(encoding, "base64") != 0)
        {
          return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
                                   _("Unsupported encoding '%s'"),
                                   encoding);
        }

      decoded = svn_base64_decode_string(cdata, result_pool);
    }
  else
    {
      decoded = svn_string_dup(cdata, result_pool);
    }

  /* Caller has ensured PROPNAME has sufficient lifetime.  */
  svn_hash_sets(revprops, propname, decoded);

  return SVN_NO_ERROR;
}


/* Record ACTION on the path in CDATA into PATHS. Other properties about
   the action are pulled from ATTRS.  */
static svn_error_t *
collect_path(apr_hash_t *paths,
             char action,

src/subversion/subversion/libsvn_ra_serf/util.c  view on Meta::CPAN 

  return SVN_NO_ERROR;
}

svn_error_t *
svn_ra_serf__get_relative_path(const char **rel_path,
                               const char *orig_path,
                               svn_ra_serf__session_t *session,
                               svn_ra_serf__connection_t *conn,
                               apr_pool_t *pool)
{
  const char *decoded_root, *decoded_orig;

  if (! session->repos_root.path)
    {
      const char *vcc_url;

      /* This should only happen if we haven't detected HTTP v2
         support from the server.  */
      assert(! SVN_RA_SERF__HAVE_HTTPV2_SUPPORT(session));

      /* We don't actually care about the VCC_URL, but this API
         promises to populate the session's root-url cache, and that's
         what we really want. */
      SVN_ERR(svn_ra_serf__discover_vcc(&vcc_url, session,
                                        conn ? conn : session->conns[0],
                                        pool));
    }

  decoded_root = svn_path_uri_decode(session->repos_root.path, pool);
  decoded_orig = svn_path_uri_decode(orig_path, pool);
  *rel_path = svn_urlpath__skip_ancestor(decoded_root, decoded_orig);
  SVN_ERR_ASSERT(*rel_path != NULL);
  return SVN_NO_ERROR;
}

svn_error_t *
svn_ra_serf__report_resource(const char **report_target,
                             svn_ra_serf__session_t *session,
                             svn_ra_serf__connection_t *conn,
                             apr_pool_t *pool)
{

src/subversion/subversion/libsvn_repos/repos.c  view on Meta::CPAN 

  return SVN_NO_ERROR;
}



const char *
svn_repos_find_root_path(const char *path,
                         apr_pool_t *pool)
{
  const char *candidate = path;
  const char *decoded;
  svn_error_t *err;

  while (1)
    {
      /* Try to decode the path, so we don't fail if it contains characters
         that aren't supported by the OS filesystem.  The subversion fs
         isn't restricted by the OS filesystem character set. */
      err = svn_path_cstring_from_utf8(&decoded, candidate, pool);
      if (!err && check_repos_path(candidate, pool))
        break;
      svn_error_clear(err);

      if (svn_path_is_empty(candidate) ||
          svn_dirent_is_root(candidate, strlen(candidate)))
        return NULL;

      candidate = svn_dirent_dirname(candidate, pool);
    }

src/subversion/subversion/libsvn_subr/base64.c  view on Meta::CPAN 

{
  return svn_base64_encode_string2(str, TRUE, pool);
}



/* Base64-encoded input --> binary output */

struct decode_baton {
  svn_stream_t *output;
  unsigned char buf[4];         /* Bytes waiting to be decoded */
  int buflen;                   /* Number of bytes waiting */
  svn_boolean_t done;           /* True if we already saw an '=' */
  apr_pool_t *scratch_pool;
};


/* Base64-decode a group.  IN needs to have four bytes and OUT needs
   to have room for three bytes.  The input bytes must already have
   been decoded from base64tab into the range 0..63.  The four
   six-bit values are pasted together to form three eight-bit bytes.  */
static APR_INLINE void
decode_group(const unsigned char *in, char *out)
{
  out[0] = (char)((in[0] << 2) | (in[1] >> 4));
  out[1] = (char)(((in[1] & 0xf) << 4) | (in[2] >> 2));
  out[2] = (char)(((in[2] & 0x3) << 6) | in[3]);
}

/* Lookup table for base64 characters; reverse_base64[ch] gives a

src/subversion/subversion/libsvn_subr/base64.c  view on Meta::CPAN 

  char group[3];
  signed char find;
  const char *end = data + len;

  /* Resize the stringbuf to make room for the maximum size of output,
     to avoid repeated resizes later.  The optimizations in
     decode_line rely on no resizes being necessary!

     (*inbuflen+len) is encoded data length
     (*inbuflen+len)/4 is the number of complete 4-bytes sets
     (*inbuflen+len)/4*3 is the number of decoded bytes
     svn_stringbuf_ensure will add an additional byte for the terminating 0.
  */
  svn_stringbuf_ensure(str, str->len + ((*inbuflen + len) / 4) * 3);

  while ( !*done && p < end )
    {
      /* If no data is left in temporary INBUF and there is at least
         one line-sized chunk left to decode, we may use the optimized
         code path. */
      if ((*inbuflen == 0) && (p + BASE64_LINELEN <= end))

src/subversion/subversion/libsvn_subr/base64.c  view on Meta::CPAN 

        }
    }
}


/* Write handler for svn_base64_decode.  */
static svn_error_t *
decode_data(void *baton, const char *data, apr_size_t *len)
{
  struct decode_baton *db = baton;
  svn_stringbuf_t *decoded;
  apr_size_t declen;
  svn_error_t *err = SVN_NO_ERROR;

  /* Decode this block of data.  */
  decoded = svn_stringbuf_create_empty(db->scratch_pool);
  decode_bytes(decoded, data, *len, db->buf, &db->buflen, &db->done);

  /* Write the output, clean up, go home.  */
  declen = decoded->len;
  if (declen != 0)
    err = svn_stream_write(db->output, decoded->data, &declen);
  svn_pool_clear(db->scratch_pool);
  return err;
}


/* Close handler for svn_base64_decode().  */
static svn_error_t *
finish_decoding_data(void *baton)
{
  struct decode_baton *db = baton;

src/subversion/subversion/libsvn_subr/base64.c  view on Meta::CPAN 

  stream = svn_stream_create(db, pool);
  svn_stream_set_write(stream, decode_data);
  svn_stream_set_close(stream, finish_decoding_data);
  return stream;
}


const svn_string_t *
svn_base64_decode_string(const svn_string_t *str, apr_pool_t *pool)
{
  svn_stringbuf_t *decoded = svn_stringbuf_create_empty(pool);
  unsigned char ingroup[4];
  int ingrouplen = 0;
  svn_boolean_t done = FALSE;

  decode_bytes(decoded, str->data, str->len, ingroup, &ingrouplen, &done);
  return svn_stringbuf__morph_into_string(decoded);
}


/* Return a base64-encoded representation of CHECKSUM, allocated in POOL.
   If CHECKSUM->kind is not recognized, return NULL.
   ### That 'NULL' claim was in the header file when this was public, but
   doesn't look true in the implementation.

   ### This is now only used as a new implementation of svn_base64_from_md5();
   it would probably be safer to revert that to its old implementation. */

src/subversion/subversion/libsvn_subr/dirent_uri.c  view on Meta::CPAN 

    If we got a non-empty hostname other than localhost, we convert this
    into an UNC path.  In this case, we obviously don't strip the slash
    even if the path looks like it starts with a drive letter.
  */
  {
    static const char valid_drive_letters[] =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    /* Casting away const! */
    char *dup_path = (char *)svn_path_uri_decode(path, pool);

    /* This check assumes ':' and '|' are already decoded! */
    if (!hostname && dup_path[1] && strchr(valid_drive_letters, dup_path[1])
        && (dup_path[2] == ':' || dup_path[2] == '|'))
      {
        /* Skip the leading slash. */
        ++dup_path;

        if (dup_path[1] == '|')
          dup_path[1] = ':';

        if (dup_path[2] == '/' || dup_path[2] == '\0')

src/subversion/subversion/libsvn_subr/quoprint.c  view on Meta::CPAN 

    svn_stringbuf_appendcstr(encoded, "=\n");
  return encoded;
}



/* Quoted-printable-encoded input --> binary output */

struct decode_baton {
  svn_stream_t *output;
  char buf[3];                  /* Bytes waiting to be decoded */
  int buflen;                   /* Number of bytes waiting */
  apr_pool_t *pool;
};


/* Decode a byte string which may or may not be the total amount of
   data being decoded.  INBUF and *INBUFLEN carry the leftover bytes
   from call to call.  Have room for four bytes in INBUF and
   initialize *INBUFLEN to 0 and *DONE to FALSE.  Output will be
   appended to STR.  */
static void
decode_bytes(svn_stringbuf_t *str, const char *data, apr_size_t len,
             char *inbuf, int *inbuflen)
{
  const char *p, *find1, *find2;
  char c;

src/subversion/subversion/libsvn_subr/quoprint.c  view on Meta::CPAN 

    }
}


/* Write handler for svn_quoprint_decode.  */
static svn_error_t *
decode_data(void *baton, const char *data, apr_size_t *len)
{
  struct decode_baton *db = baton;
  apr_pool_t *subpool;
  svn_stringbuf_t *decoded;
  apr_size_t declen;
  svn_error_t *err = SVN_NO_ERROR;

  /* Decode this block of data.  */
  subpool = svn_pool_create(db->pool);
  decoded = svn_stringbuf_create_empty(subpool);
  decode_bytes(decoded, data, *len, db->buf, &db->buflen);

  /* Write the output, clean up, go home.  */
  declen = decoded->len;
  if (declen != 0)
    err = svn_stream_write(db->output, decoded->data, &declen);
  svn_pool_destroy(subpool);
  return err;
}


/* Close handler for svn_quoprint_decode().  */
static svn_error_t *
finish_decoding_data(void *baton)
{
  struct decode_baton *db = baton;

src/subversion/subversion/libsvn_subr/quoprint.c  view on Meta::CPAN 

  stream = svn_stream_create(db, pool);
  svn_stream_set_write(stream, decode_data);
  svn_stream_set_close(stream, finish_decoding_data);
  return stream;
}


svn_stringbuf_t *
svn_quoprint_decode_string(const svn_stringbuf_t *str, apr_pool_t *pool)
{
  svn_stringbuf_t *decoded = svn_stringbuf_create_empty(pool);
  char ingroup[4];
  int ingrouplen = 0;

  decode_bytes(decoded, str->data, str->len, ingroup, &ingrouplen);
  return decoded;
}

src/subversion/subversion/po/de.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:565
msgid "Decompression of svndiff data failed"
msgstr "Dekomprimierung der svndiff-Daten schlug fehl"

#: ../libsvn_delta/svndiff.c:572
msgid "Size of uncompressed data does not match stored original length"
msgstr "Die Größe der unkomprimierten Daten entspricht nicht der gespeicherten Originallänge"

#: ../libsvn_delta/svndiff.c:648
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "Ungültiger Diff-Strom: insn %d kann nicht dekodiert werden"

#: ../libsvn_delta/svndiff.c:652
#, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "Ungültiger Diff-Strom: insn %d hat Länge Null"

#: ../libsvn_delta/svndiff.c:656
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/es.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:456
msgid "Decompression of svndiff data failed"
msgstr "Falló la decompresión de datos svndiff"

#: ../libsvn_delta/svndiff.c:463
msgid "Size of uncompressed data does not match stored original length"
msgstr "El tamaño de los datos descomprimidos no corresponde con el largo original almacenado"

#: ../libsvn_delta/svndiff.c:538
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "Flujo diff inválido: ins %d no se puede decodificar"

#: ../libsvn_delta/svndiff.c:542
#, fuzzy, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "Flujo diff inválido: la ins %d tiene un largo no positivo"

#: ../libsvn_delta/svndiff.c:546
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/fr.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:500
msgid "Decompression of svndiff data failed"
msgstr "Échec de la décompression des données de svndiff"

#: ../libsvn_delta/svndiff.c:507
msgid "Size of uncompressed data does not match stored original length"
msgstr "La taille des données décompressées ne correspond pas à la taille initiale"

#: ../libsvn_delta/svndiff.c:582
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "Flux diff invalide : insn %d ne peut être décodé"

#: ../libsvn_delta/svndiff.c:586
#, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "Flux diff invalide : insn %d de longueur nulle"

#: ../libsvn_delta/svndiff.c:590
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/it.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:456
msgid "Decompression of svndiff data failed"
msgstr "Decompressione dei dati di svndiff fallita"

#: ../libsvn_delta/svndiff.c:463
msgid "Size of uncompressed data does not match stored original length"
msgstr "La dimensione dei dati non compressi non coincide con quella originaria"

#: ../libsvn_delta/svndiff.c:538
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "Flusso di diff non valido: insn %d non può essere decodificato"

#: ../libsvn_delta/svndiff.c:542
#, fuzzy, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "Flusso di diff non valido: insn %d ha una lunghezza non positiva"

#: ../libsvn_delta/svndiff.c:546
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/ja.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:456
msgid "Decompression of svndiff data failed"
msgstr "svndiff データの解凍に失敗しました"

#: ../libsvn_delta/svndiff.c:463
msgid "Size of uncompressed data does not match stored original length"
msgstr "非圧縮データのサイズが、保存されているオリジナルの長さと一致しません"

#: ../libsvn_delta/svndiff.c:538
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "diff ストリームが不正です: インストラクション %d をデコードできません"

#: ../libsvn_delta/svndiff.c:542
#, fuzzy, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "diff ストリームが不正です: インストラクション %d の長さが正でありません"

#: ../libsvn_delta/svndiff.c:546
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/ko.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:467
msgid "Decompression of svndiff data failed"
msgstr "svndiff 데이터 압축 해제를 실패하였습니다"

#: ../libsvn_delta/svndiff.c:474
msgid "Size of uncompressed data does not match stored original length"
msgstr "압축 해제된 데이터의 크기가 저장된 원본 길이와 일치하지 않습니다"

#: ../libsvn_delta/svndiff.c:549
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "잘못된 diff 스트림: insn %d 를 디코딩할 수 없습니다"

#: ../libsvn_delta/svndiff.c:553
#, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "잘못된 diff 스트림: insn %d 의 길이가 0 입니다"

#: ../libsvn_delta/svndiff.c:557
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/nb.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:456
msgid "Decompression of svndiff data failed"
msgstr "Dekomprimering av svndiff-data feilet"

#: ../libsvn_delta/svndiff.c:463
msgid "Size of uncompressed data does not match stored original length"
msgstr "Størrelsen på ukomprimerte data stemmer ikke med original lengde"

#: ../libsvn_delta/svndiff.c:538
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "Ugyldig diff-strøm: Instruksjon %d kan ikke dekodes"

#: ../libsvn_delta/svndiff.c:542
#, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "Ugyldig diff-strøm: Instruksjon %d har lengde null"

#: ../libsvn_delta/svndiff.c:546
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/pl.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:456
msgid "Decompression of svndiff data failed"
msgstr "Dekompresja danych svndiff nie powiodła się"

#: ../libsvn_delta/svndiff.c:463
msgid "Size of uncompressed data does not match stored original length"
msgstr "Rozmiar rozkomprymowanych danych różni się od oryginalnego, zapisanego rozmiaru"

#: ../libsvn_delta/svndiff.c:538
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "Niewłaściwy strumień diff: instrukcja %d nie może być rozkodowana"

#: ../libsvn_delta/svndiff.c:542
#, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "Niewłaściwy strumień diff: instrukcja %d ma zerową długość"

#: ../libsvn_delta/svndiff.c:546
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/pt_BR.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:456
msgid "Decompression of svndiff data failed"
msgstr "Descompressão de dados de svndiff falhou"

#: ../libsvn_delta/svndiff.c:463
msgid "Size of uncompressed data does not match stored original length"
msgstr "Tamanho dos dados descomprimidos não bate com o comprimento original armazenado"

#: ../libsvn_delta/svndiff.c:538
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "Cadeia diff inválida: insn %d não pode ser decodificado"

#: ../libsvn_delta/svndiff.c:542
#, fuzzy, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "Cadeia diff inválida: insn %d possui largura não-positiva"

#: ../libsvn_delta/svndiff.c:546
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/subversion.pot  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:565
msgid "Decompression of svndiff data failed"
msgstr ""

#: ../libsvn_delta/svndiff.c:572
msgid "Size of uncompressed data does not match stored original length"
msgstr ""

#: ../libsvn_delta/svndiff.c:648
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr ""

#: ../libsvn_delta/svndiff.c:652
#, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr ""

#: ../libsvn_delta/svndiff.c:656
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/sv.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:565
msgid "Decompression of svndiff data failed"
msgstr "Misslyckades med att packa upp svndiff-data"

#: ../libsvn_delta/svndiff.c:572
msgid "Size of uncompressed data does not match stored original length"
msgstr "Storleken på uppackad data stämmer inte med lagrad originallängd"

#: ../libsvn_delta/svndiff.c:648
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "Ogiltig diff-ström: instruktionen %d kan inte avkodas"

#: ../libsvn_delta/svndiff.c:652
#, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "Ogiltig diff-ström: instruktionen %d har längden noll"

#: ../libsvn_delta/svndiff.c:656
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"

src/subversion/subversion/po/zh_CN.po  view on Meta::CPAN 

#: ../libsvn_delta/svndiff.c:565
msgid "Decompression of svndiff data failed"
msgstr "解压 svndiff 数据失败"

#: ../libsvn_delta/svndiff.c:572
msgid "Size of uncompressed data does not match stored original length"
msgstr "解压后的数据长度与原始长度不相等"

#: ../libsvn_delta/svndiff.c:648
#, c-format
msgid "Invalid diff stream: insn %d cannot be decoded"
msgstr "无效的差异流: insn %d 不能解码"

#: ../libsvn_delta/svndiff.c:652
#, c-format
msgid "Invalid diff stream: insn %d has length zero"
msgstr "无效的差异流: insn %d 出现 0 长度"

#: ../libsvn_delta/svndiff.c:656
#, c-format
msgid "Invalid diff stream: insn %d overflows the target view"



( run in 0.597 second using v1.01-cache-2.11-cpan-26ccb49234f )