自学教程：C++ svn_stringbuf_create函数代码示例

/* fonction callback pour l'appel a svn_client_list2 */svn_error_t *list_callback(void *baton,			   const char *path,			   const svn_dirent_t *dirent,			   const svn_lock_t *lock,			   const char *abs_path,			   apr_pool_t *subpool){    if (strcmp(path,"") == 0) {    svn_error_t *err = svn_error_create(1,NULL,"Wrong node kind");    if (dirent->kind != svn_node_dir)       return err;    return SVN_NO_ERROR;  }  svn_stringbuf_t *temp = NULL;   if (dirent->kind == svn_node_dir){    const svn_stringbuf_t *slash = svn_stringbuf_create("/",subpool);    svn_stringbuf_t *dir_format = svn_stringbuf_create(path,subpool);    svn_stringbuf_appendstr(dir_format,slash);    temp = stringbuf_endline_utf8(dir_format->data,subpool);  }   else    temp = stringbuf_endline_utf8(path,subpool);  svn_stringbuf_t *author = stringbuf_endline_utf8(dirent->last_author,subpool);  char *rev = apr_psprintf(subpool,"%d/n",(int)dirent->created_rev);  svn_stringbuf_t *revbuf = stringbuf_endline_utf8(rev,subpool);  svn_stringbuf_appendstr((svn_stringbuf_t *)baton, (const svn_stringbuf_t *)temp);  svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)author);  svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)revbuf);  return SVN_NO_ERROR;}

svn_error_t *svn_config_read(svn_config_t **cfgp, const char *file,                svn_boolean_t must_exist, apr_pool_t *pool){  svn_config_t *cfg = apr_palloc(pool, sizeof(*cfg));  svn_error_t *err;  cfg->sections = apr_hash_make(pool);  cfg->pool = pool;  cfg->x_pool = svn_pool_create(pool);  cfg->x_values = FALSE;  cfg->tmp_key = svn_stringbuf_create("", pool);  cfg->tmp_value = svn_stringbuf_create("", pool);  /* Yes, this is platform-specific code in Subversion, but there's no     practical way to migrate it into APR, as it's simultaneously     Subversion-specific and Windows-specific.  Even if we eventually     want to have APR offer a generic config-reading interface, it     makes sense to test it here first and migrate it later. */#ifdef WIN32  if (0 == strncmp(file, SVN_REGISTRY_PREFIX, SVN_REGISTRY_PREFIX_LEN))    err = svn_config__parse_registry(cfg, file + SVN_REGISTRY_PREFIX_LEN,                                     must_exist, pool);  else#endif /* WIN32 */    err = svn_config__parse_file(cfg, file, must_exist, pool);  if (err != SVN_NO_ERROR)    return err;  else    *cfgp = cfg;  return SVN_NO_ERROR;}

/* Merge CHUNK1 and CHUNK2 into a new chunk with conflict markers. */static apr_array_header_t *merge_chunks_with_conflict_markers(apr_array_header_t *chunk1,                                   apr_array_header_t *chunk2,                                   apr_pool_t *result_pool){  apr_array_header_t *merged_chunk;  int i;  merged_chunk = apr_array_make(result_pool, 0, sizeof(svn_stringbuf_t *));  /* ### would be nice to show filenames next to conflict markers */  APR_ARRAY_PUSH(merged_chunk, svn_stringbuf_t *) =    svn_stringbuf_create("<<<<<<</n", result_pool);  for (i = 0; i < chunk1->nelts; i++)    {      APR_ARRAY_PUSH(merged_chunk, svn_stringbuf_t *) =        APR_ARRAY_IDX(chunk1, i, svn_stringbuf_t*);    }  APR_ARRAY_PUSH(merged_chunk, svn_stringbuf_t *) =    svn_stringbuf_create("=======/n", result_pool);  for (i = 0; i < chunk2->nelts; i++)    {      APR_ARRAY_PUSH(merged_chunk, svn_stringbuf_t *) =        APR_ARRAY_IDX(chunk2, i, svn_stringbuf_t*);    }  APR_ARRAY_PUSH(merged_chunk, svn_stringbuf_t *) =    svn_stringbuf_create(">>>>>>>/n", result_pool);  return merged_chunk;}

static svn_error_t *test_stream_base64(apr_pool_t *pool){  svn_stream_t *stream;  svn_stringbuf_t *actual = svn_stringbuf_create("", pool);  svn_stringbuf_t *expected = svn_stringbuf_create("", pool);  int i;  static const char *strings[] = {    "fairly boring test data... blah blah",    "A",    "abc",    "012345679",    NULL  };  stream = svn_stream_from_stringbuf(actual, pool);  stream = svn_base64_decode(stream, pool);  stream = svn_base64_encode(stream, pool);  for (i = 0; strings[i]; i++)    {      apr_size_t len = strlen(strings[i]);      svn_stringbuf_appendbytes(expected, strings[i], len);      SVN_ERR(svn_stream_write(stream, strings[i], &len));    }  SVN_ERR(svn_stream_close(stream));  SVN_TEST_STRING_ASSERT(actual->data, expected->data);  return SVN_NO_ERROR;}

/* Read a line of original or modified hunk text from the specified * RANGE within FILE. FILE is expected to contain unidiff text. * Leading unidiff symbols ('+', '-', and ' ') are removed from the line, * Any lines commencing with the VERBOTEN character are discarded. * VERBOTEN should be '+' or '-', depending on which form of hunk text * is being read. * * All other parameters are as in svn_diff_hunk_readline_original_text() * and svn_diff_hunk_readline_modified_text(). */static svn_error_t *hunk_readline_original_or_modified(apr_file_t *file,                                   struct svn_diff__hunk_range *range,                                   svn_stringbuf_t **stringbuf,                                   const char **eol,                                   svn_boolean_t *eof,                                   char verboten,                                   apr_pool_t *result_pool,                                   apr_pool_t *scratch_pool){  apr_size_t max_len;  svn_boolean_t filtered;  apr_off_t pos;  svn_stringbuf_t *str;  if (range->current >= range->end)    {      /* We're past the range. Indicate that no bytes can be read. */      *eof = TRUE;      if (eol)        *eol = NULL;      *stringbuf = svn_stringbuf_create("", result_pool);      return SVN_NO_ERROR;    }  pos = 0;  SVN_ERR(svn_io_file_seek(file, APR_CUR, &pos,  scratch_pool));  SVN_ERR(svn_io_file_seek(file, APR_SET, &range->current, scratch_pool));  do    {      max_len = range->end - range->current;      SVN_ERR(readline(file, &str, eol, eof, max_len,                       result_pool, scratch_pool));      range->current = 0;      SVN_ERR(svn_io_file_seek(file, APR_CUR, &range->current, scratch_pool));      filtered = (str->data[0] == verboten || str->data[0] == '//');    }  while (filtered && ! *eof);  if (filtered)    {      /* EOF, return an empty string. */      *stringbuf = svn_stringbuf_create_ensure(0, result_pool);    }  else if (str->data[0] == '+' || str->data[0] == '-' || str->data[0] == ' ')    {      /* Shave off leading unidiff symbols. */      *stringbuf = svn_stringbuf_create(str->data + 1, result_pool);    }  else    {      /* Return the line as-is. */      *stringbuf = svn_stringbuf_dup(str, result_pool);    }  SVN_ERR(svn_io_file_seek(file, APR_SET, &pos, scratch_pool));  return SVN_NO_ERROR;}

/* création d'un stringbuf dont la chaine se termine par un "/n" */svn_stringbuf_t *stringbuf_endline_utf8(const char *string,apr_pool_t *subpool){    const svn_stringbuf_t *endline = svn_stringbuf_create("/n",subpool);  svn_stringbuf_t *res_utf8,*res = svn_stringbuf_create(string,subpool);  svn_stringbuf_appendstr(res,endline);  svn_utf_stringbuf_to_utf8(&res_utf8,res,subpool);    return res_utf8;}

apr_array_header_t *svn_support_diff(char *rep_path,                                     char *filename,                                     int revision1,                                     int revision2){  apr_pool_t *subpool = svn_pool_create(pool);  svn_stringbuf_t * rep = svn_stringbuf_create(rep_path, subpool);  svn_stringbuf_t * file = svn_stringbuf_create(filename, subpool);  caml_enter_blocking_section ();  apr_array_header_t *res = svn_support_diff_call(rep->data,file->data,revision1,revision2,subpool);   caml_leave_blocking_section ();  return res;}

svn_error_t *svn_fs_fs__dag_serialize(char **data,                         apr_size_t *data_len,                         void *in,                         apr_pool_t *pool){    dag_node_t *node = in;    svn_stringbuf_t *buf = svn_stringbuf_create("", pool);    if (svn_fs_fs__dag_check_mutable(node))    {        svn_stringbuf_appendcstr(buf, "M");        svn_stringbuf_appendcstr(buf, (node->kind == svn_node_file ? "F" : "D"));        svn_stringbuf_appendcstr(buf, svn_fs_fs__id_unparse(node->id,                                 pool)->data);        svn_stringbuf_appendcstr(buf, "/n");        svn_stringbuf_appendcstr(buf, node->created_path);    }    else    {        fs_fs_data_t *ffd = node->fs->fsap_data;        svn_stringbuf_appendcstr(buf, "I");        SVN_ERR(svn_fs_fs__write_noderev(svn_stream_from_stringbuf(buf, pool),                                         node->node_revision, ffd->format,                                         TRUE, pool));    }    *data = buf->data;    *data_len = buf->len;    return SVN_NO_ERROR;}

static svn_error_t *test7(const char **msg,      svn_boolean_t msg_only,      svn_test_opts_t *opts,      apr_pool_t *pool){  char *tmp;  size_t tmp_len;  *msg = "chopping a string";  if (msg_only)    return SVN_NO_ERROR;  c = svn_stringbuf_create(phrase_2, pool);  tmp_len = c->len;  tmp = apr_palloc(pool, c->len + 1);  strcpy(tmp, c->data);  svn_stringbuf_chop(c, 11);  if ((c->len == (tmp_len - 11))      && (strncmp(tmp, c->data, c->len) == 0)      && (c->data[c->len] == '/0'))    return SVN_NO_ERROR;  else    return fail(pool, "test failed");}

static svn_error_t *test3(const char **msg,      svn_boolean_t msg_only,      svn_test_opts_t *opts,      apr_pool_t *pool){  char *tmp;  size_t old_len;  *msg = "append svn_stringbuf_t to svn_stringbuf_t";  if (msg_only)    return SVN_NO_ERROR;  a = svn_stringbuf_create(phrase_1, pool);  b = svn_stringbuf_ncreate(phrase_2, 16, pool);  tmp = apr_palloc(pool, (a->len + b->len + 1));  strcpy(tmp, a->data);  strcat(tmp, b->data);  old_len = a->len;  svn_stringbuf_appendstr(a, b);  /* Test that length, data, and null-termination are correct. */  if ((a->len == (old_len + b->len)) && ((strcmp(a->data, tmp)) == 0))    return SVN_NO_ERROR;  else    return fail(pool, "test failed");}

CContentInstance* CContentFieldSvnPresentProps::getInstance(const char* pchPath){	CSvnPool oPool;	apr_hash_t* pProps = getParent().getPropsForPath(pchPath, oPool);	if (!pProps)	{		return new CContentInstanceEmpty(*this, pchPath);	}	svn_stringbuf_t* pBuf = svn_stringbuf_create("", oPool);	svn_stringbuf_ensure(pBuf, apr_hash_count(pProps) * 16);	for (apr_hash_index_t* pIdx = apr_hash_first(oPool, pProps); pIdx; pIdx = apr_hash_next(pIdx))	{		const char* pchPropName;		int iSize = 0;		apr_hash_this(pIdx, reinterpret_cast<const void**>(&pchPropName), &iSize, NULL);		svn_stringbuf_appendcstr(pBuf, pchPropName);		svn_stringbuf_appendcstr(pBuf, " ");	}	svn_stringbuf_chop(pBuf, 1);	return new CContentInstanceString(*this, pchPath, pBuf->data, pBuf->len);}

/* This implements `svn_opt_subcommand_t'. */static svn_error_t *subcommand_help (apr_getopt_t *os, void *baton, apr_pool_t *pool){  struct svnindex_opt_state *opt_state = baton;  const char *header =    _("general usage: svnindex SUBCOMMAND REPOS_PATH  [ARGS & OPTIONS ...]/n"      "Type 'svnindex help <subcommand>' for help on a specific"      " subcommand./n"      "/n"      "Available subcommands:/n");  const char *fs_desc_start    = _("The following repository back-end (FS) modules are available:/n/n");  svn_stringbuf_t *version_footer;  version_footer = svn_stringbuf_create (fs_desc_start, pool);  SVN_ERR (svn_fs_print_modules (version_footer, pool));  SVN_ERR (svn_opt_print_help (os, "svnindex",                                opt_state ? opt_state->version : FALSE,                               FALSE, version_footer->data,                               header, cmd_table, options_table, NULL,                               pool));    return SVN_NO_ERROR;}

/* Given a string like "HTTP/1.1 500 (status)" in BUF, parse out the numeric   status code into *STATUS_CODE_OUT.  Ignores leading whitespace. */static svn_error_t *parse_status_line(int *status_code_out,                  const char **reason,                  const char *status_line,                  apr_pool_t *result_pool,                  apr_pool_t *scratch_pool){  svn_error_t *err;  const char *token;  char *tok_status;  svn_stringbuf_t *temp_buf = svn_stringbuf_create(status_line, scratch_pool);  svn_stringbuf_strip_whitespace(temp_buf);  token = apr_strtok(temp_buf->data, " /t/r/n", &tok_status);  if (token)    token = apr_strtok(NULL, " /t/r/n", &tok_status);  if (!token)    return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,                             _("Malformed DAV:status '%s'"),                             status_line);  err = svn_cstring_atoi(status_code_out, token);  if (err)    return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA, err,                             _("Malformed DAV:status '%s'"),                             status_line);  token = apr_strtok(NULL, " /t/r/n", &tok_status);  *reason = apr_pstrdup(result_pool, token);  return SVN_NO_ERROR;}

/* Set *HANDLE to an open filehandle for a temporary file (i.e.,   automatically deleted when closed), into which the LOCK_TOKENS have   been written out in the format described in the pre-commit hook   template.   LOCK_TOKENS is as returned by svn_fs__access_get_lock_tokens().   Allocate *HANDLE in POOL, and use POOL for temporary allocations. */static svn_error_t *lock_token_content(apr_file_t **handle, apr_hash_t *lock_tokens,                   apr_pool_t *pool){  svn_stringbuf_t *lock_str = svn_stringbuf_create("LOCK-TOKENS:/n", pool);  apr_hash_index_t *hi;  for (hi = apr_hash_first(pool, lock_tokens); hi;       hi = apr_hash_next(hi))    {      void *val;      const char *path, *token;      apr_hash_this(hi, (void *)&token, NULL, &val);      path = val;      svn_stringbuf_appendstr(lock_str,        svn_stringbuf_createf(pool, "%s|%s/n",                              svn_path_uri_autoescape(path, pool),                              token));    }  svn_stringbuf_appendcstr(lock_str, "/n");  return create_temp_file(handle,                          svn_stringbuf__morph_into_string(lock_str), pool);}

static svn_error_t *subcommand_help(apr_getopt_t *os, void *baton, apr_pool_t *pool){  struct svnauthz_opt_state *opt_state = baton;  const char *header =    ("general usage: svnauthz SUBCOMMAND TARGET [ARGS & OPTIONS ...]/n"     "               " SVNAUTHZ_COMPAT_NAME " TARGET/n/n"     "If the command name starts with '" SVNAUTHZ_COMPAT_NAME "', runs in/n"     "pre-1.8 compatibility mode: run the 'validate' subcommand on TARGET./n/n"     "Type 'svnauthz help <subcommand>' for help on a specific subcommand./n"     "Type 'svnauthz --version' to see the program version./n/n"     "Available subcommands:/n");  const char *fs_desc_start    = ("The following repository back-end (FS) modules are available:/n/n");  svn_stringbuf_t *version_footer;  version_footer = svn_stringbuf_create(fs_desc_start, pool);  SVN_ERR(svn_fs_print_modules(version_footer, pool));  SVN_ERR(svn_opt_print_help4(os, "svnauthz",                              opt_state ? opt_state->version : FALSE,                              FALSE, /* quiet */                              FALSE, /* verbose */                              version_footer->data,                              header, cmd_table, options_table, NULL, NULL,                              pool));  return SVN_NO_ERROR;}

static ne_xml_parser *error_parser_create(svn_ra_neon__request_t *req){  error_parser_baton_t *b = apr_palloc(req->pool, sizeof(*b));  ne_xml_parser *error_parser;  b->dst_err = &(req->err);  b->marshalled_error = &(req->marshalled_error);  b->tmp_err = NULL;  b->want_cdata = NULL;  b->cdata = svn_stringbuf_create("", req->pool);  /* attach a standard <D:error> body parser to the request */  error_parser = xml_parser_create(req);  ne_xml_push_handler(error_parser,                      start_err_element,                      collect_error_cdata,                      end_err_element, b);  apr_pool_cleanup_register(req->pool, b,                            error_parser_baton_cleanup,                            apr_pool_cleanup_null);  /* Register the "error" accepter and body-reader with the request --     the one to use when HTTP status is *not* 2XX */  attach_ne_body_reader(req, ra_neon_error_accepter,                        ne_xml_parse_v, error_parser);  return error_parser;}

/* * mw_svn_get() * * Return the contents of the head of the file at subversion location * <url>.  On failure return NULL. */char *mw_svn_get(const char *url, void *baton, apr_pool_t *pool){	svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;	svn_stream_t *out;	apr_pool_t *subpool = svn_pool_create(pool);	svn_stringbuf_t *string;	svn_error_t *err = NULL;	svn_opt_revision_t rev;	char *res;	string = svn_stringbuf_create("", pool);	out = svn_stream_from_stringbuf(string, pool);	/* For now, we always want the HEAD revision, but in future we	 * may want to support specifying a revision here.*/	rev.kind = svn_opt_revision_head;	svn_pool_clear(subpool);	err = svn_client_cat(out, url, &rev, ctx, subpool);	if (err != NULL) {		svn_pool_destroy(subpool);		svn_stream_close(out);		return (NULL);	}	res = xstrdup(string->data);	svn_pool_destroy(subpool);	svn_stream_close(out);	return (res);}

voidsvn_cl__check_boolean_prop_val(const char *propname, const char *propval,                               apr_pool_t *pool){  svn_stringbuf_t *propbuf;  if (!svn_prop_is_boolean(propname))    return;  propbuf = svn_stringbuf_create(propval, pool);  svn_stringbuf_strip_whitespace(propbuf);  if (propbuf->data[0] == '/0'      || svn_cstring_casecmp(propbuf->data, "0") == 0      || svn_cstring_casecmp(propbuf->data, "no") == 0      || svn_cstring_casecmp(propbuf->data, "off") == 0      || svn_cstring_casecmp(propbuf->data, "false") == 0)    {      svn_error_t *err = svn_error_createf        (SVN_ERR_BAD_PROPERTY_VALUE, NULL,         _("To turn off the %s property, use 'svn propdel';/n"           "setting the property to '%s' will not turn it off."),           propname, propval);      svn_handle_warning2(stderr, err, "svn: ");      svn_error_clear(err);    }}

static svn_error_t *test_stringbuf_unequal(const char* str1,                       const char* str2,                       svn_boolean_t msg_only,                       apr_pool_t *pool){  if (msg_only)    return SVN_NO_ERROR;  a = svn_stringbuf_create(str1, pool);  b = svn_stringbuf_create(str2, pool);  if (svn_stringbuf_compare(a, b))    return fail(pool, "test failed");  else    return SVN_NO_ERROR;}

/* fonction faite pour récuperer un unique objet info et le stocker dans baton */svn_error_t* svn_info_callback(void *baton, const char *path,                                const svn_info_t *info, apr_pool_t *pool){  char *rev = apr_psprintf(pool,"%d/n",(int)info->last_changed_rev);  svn_stringbuf_t *res = svn_stringbuf_create(rev,pool);  svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)res);  return SVN_NO_ERROR;} 

svn_error_t *svn_ra_print_ra_libraries(svn_stringbuf_t **descriptions,                          void *ra_baton,                          apr_pool_t *pool){  *descriptions = svn_stringbuf_create("", pool);  return svn_ra_print_modules(*descriptions, pool);}

/* Create a status parser attached to the request REQ.  Detected errors   will be returned there. */static voidmultistatus_parser_create(svn_ra_neon__request_t *req){  multistatus_baton_t *b = apr_pcalloc(req->pool, sizeof(*b));  /* Create a parser, attached to REQ. (Ignore the return value.) */  svn_ra_neon__xml_parser_create(req, ne_accept_207,                                 start_207_element,                                 svn_ra_neon__xml_collect_cdata,                                 end_207_element, b);  b->cdata = svn_stringbuf_create("", req->pool);  b->description = svn_stringbuf_create("", req->pool);  b->req = req;  b->propname = svn_stringbuf_create("", req->pool);  b->propstat_description = svn_stringbuf_create("", req->pool);}

static svn_error_t *read_packed_fs(const char **msg,               svn_boolean_t msg_only,               svn_test_opts_t *opts,               apr_pool_t *pool){  svn_fs_t *fs;  svn_stream_t *rstream;  svn_stringbuf_t *rstring;  svn_revnum_t i;  *msg = "read from a packed FSFS filesystem";  if (msg_only)    return SVN_NO_ERROR;  /* Bail (with success) on known-untestable scenarios */  if ((strcmp(opts->fs_type, "fsfs") != 0)      || (opts->server_minor_version && (opts->server_minor_version < 6)))    return SVN_NO_ERROR;  SVN_ERR(create_packed_filesystem(REPO_NAME, opts, 11, 5, pool));  SVN_ERR(svn_fs_open(&fs, REPO_NAME, NULL, pool));  for (i = 1; i < 12; i++)    {      svn_fs_root_t *rev_root;      svn_stringbuf_t *sb;      SVN_ERR(svn_fs_revision_root(&rev_root, fs, i, pool));      SVN_ERR(svn_fs_file_contents(&rstream, rev_root, "iota", pool));      SVN_ERR(svn_test__stream_to_string(&rstring, rstream, pool));      if (i == 1)        sb = svn_stringbuf_create("This is the file 'iota'./n", pool);      else        sb = svn_stringbuf_create(get_rev_contents(i, pool), pool);      if (! svn_stringbuf_compare(rstring, sb))        return svn_error_createf(SVN_ERR_FS_GENERAL, NULL,                                 "Bad data in revision %ld.", i);    }  return SVN_NO_ERROR;}

apr_status_tsvn_subr__win32_xlate_to_stringbuf(win32_xlate_t *handle,                                   const char *src_data,                                   apr_size_t src_length,                                   svn_stringbuf_t **dest,                                   apr_pool_t *pool){  WCHAR * wide_str;  int retval, wide_size;  *dest = svn_stringbuf_create("", pool);  if (src_length == 0)    return APR_SUCCESS;  retval = MultiByteToWideChar(handle->from_page_id, 0, src_data, src_length,                               NULL, 0);  if (retval == 0)    return apr_get_os_error();  wide_size = retval;  /* Allocate temporary buffer for small strings on stack instead of heap. */  if (wide_size <= MAX_PATH)    {      wide_str = alloca(wide_size * sizeof(WCHAR));    }  else    {      wide_str = apr_palloc(pool, wide_size * sizeof(WCHAR));    }  retval = MultiByteToWideChar(handle->from_page_id, 0, src_data, src_length,                               wide_str, wide_size);  if (retval == 0)    return apr_get_os_error();  retval = WideCharToMultiByte(handle->to_page_id, 0, wide_str, wide_size,                               NULL, 0, NULL, NULL);  if (retval == 0)    return apr_get_os_error();  /* Ensure that buffer is enough to hold result string and termination     character. */  svn_stringbuf_ensure(*dest, retval + 1);  (*dest)->len = retval;  retval = WideCharToMultiByte(handle->to_page_id, 0, wide_str, wide_size,                               (*dest)->data, (*dest)->len, NULL, NULL);  if (retval == 0)    return apr_get_os_error();  (*dest)->len = retval;  return APR_SUCCESS;}

static svn_error_t *verify_expected_record(svn_fs_t *fs,                       const char *key,                       const char *expected_text,                       apr_size_t expected_len,                       trail_t *trail){  apr_size_t size;  char buf[100];  svn_stringbuf_t *text;  svn_filesize_t offset = 0;  svn_filesize_t string_size;  /* Check the string size. */  SVN_ERR(svn_fs_bdb__string_size(&string_size, fs, key,                                  trail, trail->pool));  if (string_size > SVN_MAX_OBJECT_SIZE)    return svn_error_createf(SVN_ERR_FS_GENERAL, NULL,                             "record size is too large "                             "(got %" SVN_FILESIZE_T_FMT ", "                             "limit is %" APR_SIZE_T_FMT ")",                             string_size, SVN_MAX_OBJECT_SIZE);  size = (apr_size_t) string_size;  if (size != expected_len)    return svn_error_createf(SVN_ERR_FS_GENERAL, NULL,                             "record has unexpected size "                             "(got %" APR_SIZE_T_FMT ", "                             "expected %" APR_SIZE_T_FMT ")",                             size, expected_len);  /* Read the string back in 100-byte chunks. */  text = svn_stringbuf_create("", trail->pool);  while (1)    {      size = sizeof(buf);      SVN_ERR(svn_fs_bdb__string_read(fs, key, buf, offset, &size,                                      trail, trail->pool));      if (size == 0)        break;      svn_stringbuf_appendbytes(text, buf, size);      offset += size;    }  /* Check the size and contents of the read data. */  if (text->len != expected_len)    return svn_error_createf(SVN_ERR_FS_GENERAL, NULL,                             "record read returned unexpected size "                             "(got %" APR_SIZE_T_FMT ", "                             "expected %" APR_SIZE_T_FMT ")",                             size, expected_len);  if (memcmp(expected_text, text->data, expected_len))    return svn_error_create(SVN_ERR_FS_GENERAL, NULL,                            "record read returned unexpected data");  return SVN_NO_ERROR;}

/* Prints XML target element with path attribute TARGET, using POOL for   temporary allocations. */static svn_error_t *print_start_target_xml(const char *target, apr_pool_t *pool){    svn_stringbuf_t *sb = svn_stringbuf_create("", pool);    svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "target",                          "path", target, NULL);    return svn_cl__error_checked_fputs(sb->data, stdout);}

svn_error_t *svn_cl__xml_print_footer(const char *tagname,                         apr_pool_t *pool){  svn_stringbuf_t *sb = svn_stringbuf_create("", pool);  /* "</TAGNAME>" */  svn_xml_make_close_tag(&sb, pool, tagname);  return svn_cl__error_checked_fputs(sb->data, stdout);}