2 * deprecated.c: holding file for all deprecated APIs.
3 * "we can't lose 'em, but we can shun 'em!"
5 * ====================================================================
6 * Licensed to the Apache Software Foundation (ASF) under one
7 * or more contributor license agreements. See the NOTICE file
8 * distributed with this work for additional information
9 * regarding copyright ownership. The ASF licenses this file
10 * to you under the Apache License, Version 2.0 (the
11 * "License"); you may not use this file except in compliance
12 * with the License. You may obtain a copy of the License at
14 * http://www.apache.org/licenses/LICENSE-2.0
16 * Unless required by applicable law or agreed to in writing,
17 * software distributed under the License is distributed on an
18 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
19 * KIND, either express or implied. See the License for the
20 * specific language governing permissions and limitations
22 * ====================================================================
25 /* We define this here to remove any further warnings about the usage of
26 deprecated functions in this file. */
27 #define SVN_DEPRECATED
32 #include "svn_subst.h"
33 #include "svn_pools.h"
34 #include "svn_props.h"
37 #include "svn_dirent_uri.h"
40 #include "private/svn_subr_private.h"
41 #include "private/svn_wc_private.h"
47 #include "translate.h"
48 #include "workqueue.h"
50 #include "svn_private_config.h"
52 /* baton for traversal_info_update */
53 struct traversal_info_update_baton
55 struct svn_wc_traversal_info_t *traversal;
59 /* Helper for updating svn_wc_traversal_info_t structures
60 * Implements svn_wc_external_update_t */
62 traversal_info_update(void *baton,
63 const char *local_abspath,
64 const svn_string_t *old_val,
65 const svn_string_t *new_val,
67 apr_pool_t *scratch_pool)
70 svn_wc_adm_access_t *adm_access;
71 struct traversal_info_update_baton *ub = baton;
72 apr_pool_t *dup_pool = ub->traversal->pool;
73 const char *dup_val = NULL;
75 /* We make the abspath relative by retrieving the access baton
76 for the specific directory */
77 adm_access = svn_wc__adm_retrieve_internal2(ub->db, local_abspath,
81 dup_path = apr_pstrdup(dup_pool, svn_wc_adm_access_path(adm_access));
83 dup_path = apr_pstrdup(dup_pool, local_abspath);
87 dup_val = apr_pstrmemdup(dup_pool, old_val->data, old_val->len);
89 svn_hash_sets(ub->traversal->externals_old, dup_path, dup_val);
94 /* In most cases the value is identical */
95 if (old_val != new_val)
96 dup_val = apr_pstrmemdup(dup_pool, new_val->data, new_val->len);
98 svn_hash_sets(ub->traversal->externals_new, dup_path, dup_val);
101 svn_hash_sets(ub->traversal->depths, dup_path, svn_depth_to_word(depth));
106 /* Helper for functions that used to gather traversal_info */
108 gather_traversal_info(svn_wc_context_t *wc_ctx,
109 const char *local_abspath,
112 struct svn_wc_traversal_info_t *traversal_info,
113 svn_boolean_t gather_as_old,
114 svn_boolean_t gather_as_new,
115 apr_pool_t *scratch_pool)
117 apr_hash_t *externals;
118 apr_hash_t *ambient_depths;
119 apr_hash_index_t *hi;
121 SVN_ERR(svn_wc__externals_gather_definitions(&externals, &ambient_depths,
122 wc_ctx, local_abspath,
124 scratch_pool, scratch_pool));
126 for (hi = apr_hash_first(scratch_pool, externals);
128 hi = apr_hash_next(hi))
130 const char *node_abspath = apr_hash_this_key(hi);
133 relpath = svn_dirent_join(path,
134 svn_dirent_skip_ancestor(local_abspath,
136 traversal_info->pool);
139 svn_hash_sets(traversal_info->externals_old, relpath,
140 apr_hash_this_val(hi));
143 svn_hash_sets(traversal_info->externals_new, relpath,
144 apr_hash_this_val(hi));
146 svn_hash_sets(traversal_info->depths, relpath,
147 svn_hash_gets(ambient_depths, node_abspath));
154 /*** From adm_crawler.c ***/
157 svn_wc_crawl_revisions4(const char *path,
158 svn_wc_adm_access_t *adm_access,
159 const svn_ra_reporter3_t *reporter,
161 svn_boolean_t restore_files,
163 svn_boolean_t honor_depth_exclude,
164 svn_boolean_t depth_compatibility_trick,
165 svn_boolean_t use_commit_times,
166 svn_wc_notify_func2_t notify_func,
168 svn_wc_traversal_info_t *traversal_info,
171 svn_wc_context_t *wc_ctx;
172 svn_wc__db_t *wc_db = svn_wc__adm_get_db(adm_access);
173 const char *local_abspath;
175 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
176 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
178 SVN_ERR(svn_wc_crawl_revisions5(wc_ctx,
185 depth_compatibility_trick,
187 NULL /* cancel_func */,
188 NULL /* cancel_baton */,
194 SVN_ERR(gather_traversal_info(wc_ctx, local_abspath, path, depth,
195 traversal_info, TRUE, FALSE, pool));
197 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
200 /*** Compatibility wrapper: turns an svn_ra_reporter2_t into an
203 This code looks like it duplicates code in libsvn_ra/ra_loader.c,
204 but it does not. That code makes an new thing look like an old
205 thing; this code makes an old thing look like a new thing. ***/
207 struct wrap_3to2_report_baton {
208 const svn_ra_reporter2_t *reporter;
213 static svn_error_t *wrap_3to2_set_path(void *report_baton,
215 svn_revnum_t revision,
217 svn_boolean_t start_empty,
218 const char *lock_token,
221 struct wrap_3to2_report_baton *wrb = report_baton;
223 return wrb->reporter->set_path(wrb->baton, path, revision, start_empty,
228 static svn_error_t *wrap_3to2_delete_path(void *report_baton,
232 struct wrap_3to2_report_baton *wrb = report_baton;
234 return wrb->reporter->delete_path(wrb->baton, path, pool);
238 static svn_error_t *wrap_3to2_link_path(void *report_baton,
241 svn_revnum_t revision,
243 svn_boolean_t start_empty,
244 const char *lock_token,
247 struct wrap_3to2_report_baton *wrb = report_baton;
249 return wrb->reporter->link_path(wrb->baton, path, url, revision,
250 start_empty, lock_token, pool);
254 static svn_error_t *wrap_3to2_finish_report(void *report_baton,
257 struct wrap_3to2_report_baton *wrb = report_baton;
259 return wrb->reporter->finish_report(wrb->baton, pool);
263 static svn_error_t *wrap_3to2_abort_report(void *report_baton,
266 struct wrap_3to2_report_baton *wrb = report_baton;
268 return wrb->reporter->abort_report(wrb->baton, pool);
271 static const svn_ra_reporter3_t wrap_3to2_reporter = {
273 wrap_3to2_delete_path,
275 wrap_3to2_finish_report,
276 wrap_3to2_abort_report
280 svn_wc_crawl_revisions3(const char *path,
281 svn_wc_adm_access_t *adm_access,
282 const svn_ra_reporter3_t *reporter,
284 svn_boolean_t restore_files,
286 svn_boolean_t depth_compatibility_trick,
287 svn_boolean_t use_commit_times,
288 svn_wc_notify_func2_t notify_func,
290 svn_wc_traversal_info_t *traversal_info,
293 return svn_wc_crawl_revisions4(path,
295 reporter, report_baton,
299 depth_compatibility_trick,
308 svn_wc_crawl_revisions2(const char *path,
309 svn_wc_adm_access_t *adm_access,
310 const svn_ra_reporter2_t *reporter,
312 svn_boolean_t restore_files,
313 svn_boolean_t recurse,
314 svn_boolean_t use_commit_times,
315 svn_wc_notify_func2_t notify_func,
317 svn_wc_traversal_info_t *traversal_info,
320 struct wrap_3to2_report_baton wrb;
321 wrb.reporter = reporter;
322 wrb.baton = report_baton;
324 return svn_wc_crawl_revisions3(path,
326 &wrap_3to2_reporter, &wrb,
328 SVN_DEPTH_INFINITY_OR_FILES(recurse),
338 /* Baton for compat_call_notify_func below. */
339 struct compat_notify_baton_t {
340 /* Wrapped func/baton. */
341 svn_wc_notify_func_t func;
346 /* Implements svn_wc_notify_func2_t. Call BATON->func (BATON is of type
347 svn_wc__compat_notify_baton_t), passing BATON->baton and the appropriate
348 arguments from NOTIFY. */
350 compat_call_notify_func(void *baton,
351 const svn_wc_notify_t *n,
354 struct compat_notify_baton_t *nb = baton;
357 (*nb->func)(nb->baton, n->path, n->action, n->kind, n->mime_type,
358 n->content_state, n->prop_state, n->revision);
362 /*** Compatibility wrapper: turns an svn_ra_reporter_t into an
365 This code looks like it duplicates code in libsvn_ra/ra_loader.c,
366 but it does not. That code makes an new thing look like an old
367 thing; this code makes an old thing look like a new thing. ***/
369 struct wrap_2to1_report_baton {
370 const svn_ra_reporter_t *reporter;
375 static svn_error_t *wrap_2to1_set_path(void *report_baton,
377 svn_revnum_t revision,
378 svn_boolean_t start_empty,
379 const char *lock_token,
382 struct wrap_2to1_report_baton *wrb = report_baton;
384 return wrb->reporter->set_path(wrb->baton, path, revision, start_empty,
389 static svn_error_t *wrap_2to1_delete_path(void *report_baton,
393 struct wrap_2to1_report_baton *wrb = report_baton;
395 return wrb->reporter->delete_path(wrb->baton, path, pool);
399 static svn_error_t *wrap_2to1_link_path(void *report_baton,
402 svn_revnum_t revision,
403 svn_boolean_t start_empty,
404 const char *lock_token,
407 struct wrap_2to1_report_baton *wrb = report_baton;
409 return wrb->reporter->link_path(wrb->baton, path, url, revision,
414 static svn_error_t *wrap_2to1_finish_report(void *report_baton,
417 struct wrap_2to1_report_baton *wrb = report_baton;
419 return wrb->reporter->finish_report(wrb->baton, pool);
423 static svn_error_t *wrap_2to1_abort_report(void *report_baton,
426 struct wrap_2to1_report_baton *wrb = report_baton;
428 return wrb->reporter->abort_report(wrb->baton, pool);
431 static const svn_ra_reporter2_t wrap_2to1_reporter = {
433 wrap_2to1_delete_path,
435 wrap_2to1_finish_report,
436 wrap_2to1_abort_report
440 svn_wc_crawl_revisions(const char *path,
441 svn_wc_adm_access_t *adm_access,
442 const svn_ra_reporter_t *reporter,
444 svn_boolean_t restore_files,
445 svn_boolean_t recurse,
446 svn_boolean_t use_commit_times,
447 svn_wc_notify_func_t notify_func,
449 svn_wc_traversal_info_t *traversal_info,
452 struct wrap_2to1_report_baton wrb;
453 struct compat_notify_baton_t nb;
455 wrb.reporter = reporter;
456 wrb.baton = report_baton;
458 nb.func = notify_func;
459 nb.baton = notify_baton;
461 return svn_wc_crawl_revisions2(path, adm_access, &wrap_2to1_reporter, &wrb,
462 restore_files, recurse, use_commit_times,
463 compat_call_notify_func, &nb,
469 svn_wc_transmit_text_deltas2(const char **tempfile,
470 unsigned char digest[],
472 svn_wc_adm_access_t *adm_access,
473 svn_boolean_t fulltext,
474 const svn_delta_editor_t *editor,
478 const char *local_abspath;
479 svn_wc_context_t *wc_ctx;
480 const svn_checksum_t *new_text_base_md5_checksum;
482 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
483 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
484 svn_wc__adm_get_db(adm_access),
487 SVN_ERR(svn_wc__internal_transmit_text_deltas(tempfile,
489 ? &new_text_base_md5_checksum
492 local_abspath, fulltext,
497 memcpy(digest, new_text_base_md5_checksum->digest, APR_MD5_DIGESTSIZE);
499 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
503 svn_wc_transmit_text_deltas(const char *path,
504 svn_wc_adm_access_t *adm_access,
505 svn_boolean_t fulltext,
506 const svn_delta_editor_t *editor,
508 const char **tempfile,
511 return svn_wc_transmit_text_deltas2(tempfile, NULL, path, adm_access,
512 fulltext, editor, file_baton, pool);
516 svn_wc_transmit_prop_deltas(const char *path,
517 svn_wc_adm_access_t *adm_access,
518 const svn_wc_entry_t *entry,
519 const svn_delta_editor_t *editor,
521 const char **tempfile,
524 const char *local_abspath;
525 svn_wc_context_t *wc_ctx;
530 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
531 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
532 svn_wc__adm_get_db(adm_access),
535 SVN_ERR(svn_wc_transmit_prop_deltas2(wc_ctx, local_abspath, editor, baton,
538 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
541 /*** From adm_files.c ***/
543 svn_wc_ensure_adm3(const char *path,
547 svn_revnum_t revision,
551 const char *local_abspath;
552 svn_wc_context_t *wc_ctx;
555 return svn_error_create(SVN_ERR_BAD_UUID, NULL, NULL);
557 return svn_error_create(SVN_ERR_BAD_URL, NULL, NULL);
559 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
560 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL /* config */, pool, pool));
562 SVN_ERR(svn_wc_ensure_adm4(wc_ctx, local_abspath, url, repos, uuid, revision,
565 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
569 svn_wc_ensure_adm2(const char *path,
573 svn_revnum_t revision,
576 return svn_wc_ensure_adm3(path, uuid, url, repos, revision,
577 svn_depth_infinity, pool);
582 svn_wc_ensure_adm(const char *path,
585 svn_revnum_t revision,
588 return svn_wc_ensure_adm2(path, uuid, url, NULL, revision, pool);
592 svn_wc_create_tmp_file(apr_file_t **fp,
594 svn_boolean_t delete_on_close,
597 return svn_wc_create_tmp_file2(fp, NULL, path,
599 ? svn_io_file_del_on_close
600 : svn_io_file_del_none,
605 svn_wc_create_tmp_file2(apr_file_t **fp,
606 const char **new_name,
608 svn_io_file_del_t delete_when,
611 svn_wc_context_t *wc_ctx;
612 const char *local_abspath;
613 const char *temp_dir;
616 SVN_ERR_ASSERT(fp || new_name);
618 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL /* config */, pool, pool));
620 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
621 err = svn_wc__get_tmpdir(&temp_dir, wc_ctx, local_abspath, pool, pool);
622 err = svn_error_compose_create(err, svn_wc_context_destroy(wc_ctx));
624 return svn_error_trace(err);
626 SVN_ERR(svn_io_open_unique_file3(fp, new_name, temp_dir,
627 delete_when, pool, pool));
633 /*** From adm_ops.c ***/
635 svn_wc_get_pristine_contents(svn_stream_t **contents,
637 apr_pool_t *result_pool,
638 apr_pool_t *scratch_pool)
640 svn_wc_context_t *wc_ctx;
641 const char *local_abspath;
643 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, scratch_pool, scratch_pool));
644 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, scratch_pool));
646 SVN_ERR(svn_wc_get_pristine_contents2(contents,
652 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
656 svn_wc_queue_committed3(svn_wc_committed_queue_t *queue,
657 svn_wc_context_t *wc_ctx,
658 const char *local_abspath,
659 svn_boolean_t recurse,
660 const apr_array_header_t *wcprop_changes,
661 svn_boolean_t remove_lock,
662 svn_boolean_t remove_changelist,
663 const svn_checksum_t *sha1_checksum,
664 apr_pool_t *scratch_pool)
666 return svn_error_trace(
667 svn_wc_queue_committed4(queue, wc_ctx, local_abspath,
668 recurse, TRUE /* is_committed */,
669 wcprop_changes, remove_lock,
670 remove_changelist, sha1_checksum,
675 svn_wc_queue_committed2(svn_wc_committed_queue_t *queue,
677 svn_wc_adm_access_t *adm_access,
678 svn_boolean_t recurse,
679 const apr_array_header_t *wcprop_changes,
680 svn_boolean_t remove_lock,
681 svn_boolean_t remove_changelist,
682 const svn_checksum_t *md5_checksum,
683 apr_pool_t *scratch_pool)
685 svn_wc_context_t *wc_ctx;
686 const char *local_abspath;
687 const svn_checksum_t *sha1_checksum = NULL;
689 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
690 svn_wc__adm_get_db(adm_access),
692 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, scratch_pool));
694 if (md5_checksum != NULL)
697 err = svn_wc__db_pristine_get_sha1(&sha1_checksum, wc_ctx->db,
698 local_abspath, md5_checksum,
699 svn_wc__get_committed_queue_pool(queue),
702 /* Don't fail on SHA1 not found */
703 if (err && err->apr_err == SVN_ERR_WC_DB_ERROR)
705 svn_error_clear(err);
706 sha1_checksum = NULL;
712 SVN_ERR(svn_wc_queue_committed3(queue, wc_ctx, local_abspath, recurse,
714 remove_lock, remove_changelist,
715 sha1_checksum, scratch_pool));
717 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
721 svn_wc_queue_committed(svn_wc_committed_queue_t **queue,
723 svn_wc_adm_access_t *adm_access,
724 svn_boolean_t recurse,
725 const apr_array_header_t *wcprop_changes,
726 svn_boolean_t remove_lock,
727 svn_boolean_t remove_changelist,
728 const unsigned char *digest,
731 const svn_checksum_t *md5_checksum;
734 md5_checksum = svn_checksum__from_digest_md5(
735 digest, svn_wc__get_committed_queue_pool(*queue));
739 return svn_wc_queue_committed2(*queue, path, adm_access, recurse,
740 wcprop_changes, remove_lock,
741 remove_changelist, md5_checksum, pool);
745 svn_wc_process_committed_queue(svn_wc_committed_queue_t *queue,
746 svn_wc_adm_access_t *adm_access,
747 svn_revnum_t new_revnum,
748 const char *rev_date,
749 const char *rev_author,
752 svn_wc_context_t *wc_ctx;
754 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
755 svn_wc__adm_get_db(adm_access),
757 SVN_ERR(svn_wc_process_committed_queue2(queue, wc_ctx, new_revnum,
758 rev_date, rev_author,
760 SVN_ERR(svn_wc_context_destroy(wc_ctx));
766 svn_wc_process_committed4(const char *path,
767 svn_wc_adm_access_t *adm_access,
768 svn_boolean_t recurse,
769 svn_revnum_t new_revnum,
770 const char *rev_date,
771 const char *rev_author,
772 const apr_array_header_t *wcprop_changes,
773 svn_boolean_t remove_lock,
774 svn_boolean_t remove_changelist,
775 const unsigned char *digest,
778 svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
779 const char *local_abspath;
780 const svn_checksum_t *md5_checksum;
781 const svn_checksum_t *sha1_checksum = NULL;
782 svn_wc_context_t *wc_ctx;
783 svn_wc_committed_queue_t *queue;
785 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
786 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
789 md5_checksum = svn_checksum__from_digest_md5(digest, pool);
793 if (md5_checksum != NULL)
796 err = svn_wc__db_pristine_get_sha1(&sha1_checksum, db,
797 local_abspath, md5_checksum,
800 if (err && err->apr_err == SVN_ERR_WC_DB_ERROR)
802 svn_error_clear(err);
803 sha1_checksum = NULL;
809 queue = svn_wc_committed_queue_create(pool);
810 SVN_ERR(svn_wc_queue_committed3(queue, wc_ctx, local_abspath, recurse,
811 wcprop_changes, remove_lock,
813 sha1_checksum /* or NULL if not modified
817 SVN_ERR(svn_wc_process_committed_queue2(queue, wc_ctx,
818 new_revnum, rev_date, rev_author,
819 NULL, NULL /* cancel */,
822 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
827 svn_wc_process_committed3(const char *path,
828 svn_wc_adm_access_t *adm_access,
829 svn_boolean_t recurse,
830 svn_revnum_t new_revnum,
831 const char *rev_date,
832 const char *rev_author,
833 const apr_array_header_t *wcprop_changes,
834 svn_boolean_t remove_lock,
835 const unsigned char *digest,
838 return svn_wc_process_committed4(path, adm_access, recurse, new_revnum,
839 rev_date, rev_author, wcprop_changes,
840 remove_lock, FALSE, digest, pool);
844 svn_wc_process_committed2(const char *path,
845 svn_wc_adm_access_t *adm_access,
846 svn_boolean_t recurse,
847 svn_revnum_t new_revnum,
848 const char *rev_date,
849 const char *rev_author,
850 const apr_array_header_t *wcprop_changes,
851 svn_boolean_t remove_lock,
854 return svn_wc_process_committed3(path, adm_access, recurse, new_revnum,
855 rev_date, rev_author, wcprop_changes,
856 remove_lock, NULL, pool);
860 svn_wc_process_committed(const char *path,
861 svn_wc_adm_access_t *adm_access,
862 svn_boolean_t recurse,
863 svn_revnum_t new_revnum,
864 const char *rev_date,
865 const char *rev_author,
866 const apr_array_header_t *wcprop_changes,
869 return svn_wc_process_committed2(path, adm_access, recurse, new_revnum,
870 rev_date, rev_author, wcprop_changes,
875 svn_wc_maybe_set_repos_root(svn_wc_adm_access_t *adm_access,
884 svn_wc_delete3(const char *path,
885 svn_wc_adm_access_t *adm_access,
886 svn_cancel_func_t cancel_func,
888 svn_wc_notify_func2_t notify_func,
890 svn_boolean_t keep_local,
893 svn_wc_context_t *wc_ctx;
894 svn_wc__db_t *wc_db = svn_wc__adm_get_db(adm_access);
895 svn_wc_adm_access_t *dir_access;
896 const char *local_abspath;
898 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
899 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
901 /* Open access batons for everything below path, because we used to open
903 SVN_ERR(svn_wc_adm_probe_try3(&dir_access, adm_access, path,
904 TRUE, -1, cancel_func, cancel_baton, pool));
906 SVN_ERR(svn_wc_delete4(wc_ctx,
910 cancel_func, cancel_baton,
911 notify_func, notify_baton,
914 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
918 svn_wc_delete2(const char *path,
919 svn_wc_adm_access_t *adm_access,
920 svn_cancel_func_t cancel_func,
922 svn_wc_notify_func2_t notify_func,
926 return svn_wc_delete3(path, adm_access, cancel_func, cancel_baton,
927 notify_func, notify_baton, FALSE, pool);
931 svn_wc_delete(const char *path,
932 svn_wc_adm_access_t *adm_access,
933 svn_cancel_func_t cancel_func,
935 svn_wc_notify_func_t notify_func,
939 struct compat_notify_baton_t nb;
941 nb.func = notify_func;
942 nb.baton = notify_baton;
944 return svn_wc_delete2(path, adm_access, cancel_func, cancel_baton,
945 compat_call_notify_func, &nb, pool);
949 svn_wc_add_from_disk2(svn_wc_context_t *wc_ctx,
950 const char *local_abspath,
951 const apr_hash_t *props,
952 svn_wc_notify_func2_t notify_func,
954 apr_pool_t *scratch_pool)
956 SVN_ERR(svn_wc_add_from_disk3(wc_ctx, local_abspath, props, FALSE,
957 notify_func, notify_baton, scratch_pool));
962 svn_wc_add_from_disk(svn_wc_context_t *wc_ctx,
963 const char *local_abspath,
964 svn_wc_notify_func2_t notify_func,
966 apr_pool_t *scratch_pool)
968 SVN_ERR(svn_wc_add_from_disk2(wc_ctx, local_abspath, NULL,
969 notify_func, notify_baton, scratch_pool));
974 svn_wc_add3(const char *path,
975 svn_wc_adm_access_t *parent_access,
977 const char *copyfrom_url,
978 svn_revnum_t copyfrom_rev,
979 svn_cancel_func_t cancel_func,
981 svn_wc_notify_func2_t notify_func,
985 svn_wc_context_t *wc_ctx;
986 svn_wc__db_t *wc_db = svn_wc__adm_get_db(parent_access);
987 const char *local_abspath;
989 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
990 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
992 SVN_ERR(svn_wc_add4(wc_ctx, local_abspath,
995 cancel_func, cancel_baton,
996 notify_func, notify_baton, pool));
998 /* Make sure the caller gets the new access baton in the set. */
999 if (svn_wc__adm_retrieve_internal2(wc_db, local_abspath, pool) == NULL)
1001 svn_node_kind_t kind;
1003 SVN_ERR(svn_wc__db_read_kind(&kind, wc_db, local_abspath,
1004 FALSE /* allow_missing */,
1005 TRUE /* show_deleted */,
1006 FALSE /* show_hidden */, pool));
1007 if (kind == svn_node_dir)
1009 svn_wc_adm_access_t *adm_access;
1011 /* Open the access baton in adm_access' pool to give it the same
1013 SVN_ERR(svn_wc_adm_open3(&adm_access, parent_access, path, TRUE,
1014 copyfrom_url ? -1 : 0,
1015 cancel_func, cancel_baton,
1016 svn_wc_adm_access_pool(parent_access)));
1020 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1025 svn_wc_add2(const char *path,
1026 svn_wc_adm_access_t *parent_access,
1027 const char *copyfrom_url,
1028 svn_revnum_t copyfrom_rev,
1029 svn_cancel_func_t cancel_func,
1031 svn_wc_notify_func2_t notify_func,
1035 return svn_wc_add3(path, parent_access, svn_depth_infinity,
1036 copyfrom_url, copyfrom_rev,
1037 cancel_func, cancel_baton,
1038 notify_func, notify_baton, pool);
1042 svn_wc_add(const char *path,
1043 svn_wc_adm_access_t *parent_access,
1044 const char *copyfrom_url,
1045 svn_revnum_t copyfrom_rev,
1046 svn_cancel_func_t cancel_func,
1048 svn_wc_notify_func_t notify_func,
1052 struct compat_notify_baton_t nb;
1054 nb.func = notify_func;
1055 nb.baton = notify_baton;
1057 return svn_wc_add2(path, parent_access, copyfrom_url, copyfrom_rev,
1058 cancel_func, cancel_baton,
1059 compat_call_notify_func, &nb, pool);
1062 /*** From revert.c ***/
1064 svn_wc_revert4(svn_wc_context_t *wc_ctx,
1065 const char *local_abspath,
1067 svn_boolean_t use_commit_times,
1068 const apr_array_header_t *changelist_filter,
1069 svn_cancel_func_t cancel_func,
1071 svn_wc_notify_func2_t notify_func,
1073 apr_pool_t *scratch_pool)
1075 return svn_error_trace(svn_wc_revert5(wc_ctx, local_abspath,
1079 FALSE /* clear_changelists */,
1080 FALSE /* metadata_only */,
1081 cancel_func, cancel_baton,
1082 notify_func, notify_baton,
1087 svn_wc_revert3(const char *path,
1088 svn_wc_adm_access_t *parent_access,
1090 svn_boolean_t use_commit_times,
1091 const apr_array_header_t *changelist_filter,
1092 svn_cancel_func_t cancel_func,
1094 svn_wc_notify_func2_t notify_func,
1098 svn_wc_context_t *wc_ctx;
1099 svn_wc__db_t *wc_db = svn_wc__adm_get_db(parent_access);
1100 const char *local_abspath;
1102 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
1103 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1105 SVN_ERR(svn_wc_revert4(wc_ctx,
1110 cancel_func, cancel_baton,
1111 notify_func, notify_baton,
1114 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1118 svn_wc_revert2(const char *path,
1119 svn_wc_adm_access_t *parent_access,
1120 svn_boolean_t recursive,
1121 svn_boolean_t use_commit_times,
1122 svn_cancel_func_t cancel_func,
1124 svn_wc_notify_func2_t notify_func,
1128 return svn_wc_revert3(path, parent_access,
1129 SVN_DEPTH_INFINITY_OR_EMPTY(recursive),
1130 use_commit_times, NULL, cancel_func, cancel_baton,
1131 notify_func, notify_baton, pool);
1135 svn_wc_revert(const char *path,
1136 svn_wc_adm_access_t *parent_access,
1137 svn_boolean_t recursive,
1138 svn_boolean_t use_commit_times,
1139 svn_cancel_func_t cancel_func,
1141 svn_wc_notify_func_t notify_func,
1145 struct compat_notify_baton_t nb;
1147 nb.func = notify_func;
1148 nb.baton = notify_baton;
1150 return svn_wc_revert2(path, parent_access, recursive, use_commit_times,
1151 cancel_func, cancel_baton,
1152 compat_call_notify_func, &nb, pool);
1156 svn_wc_remove_from_revision_control(svn_wc_adm_access_t *adm_access,
1158 svn_boolean_t destroy_wf,
1159 svn_boolean_t instant_error,
1160 svn_cancel_func_t cancel_func,
1164 svn_wc_context_t *wc_ctx;
1165 svn_wc__db_t *wc_db = svn_wc__adm_get_db(adm_access);
1166 const char *local_abspath = svn_dirent_join(
1167 svn_wc__adm_access_abspath(adm_access),
1171 /* name must be an entry in adm_access, fail if not */
1172 SVN_ERR_ASSERT(strcmp(svn_dirent_basename(name, NULL), name) == 0);
1173 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
1175 SVN_ERR(svn_wc_remove_from_revision_control2(wc_ctx,
1179 cancel_func, cancel_baton,
1182 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1186 svn_wc_resolved_conflict4(const char *path,
1187 svn_wc_adm_access_t *adm_access,
1188 svn_boolean_t resolve_text,
1189 svn_boolean_t resolve_props,
1190 svn_boolean_t resolve_tree,
1192 svn_wc_conflict_choice_t conflict_choice,
1193 svn_wc_notify_func2_t notify_func,
1195 svn_cancel_func_t cancel_func,
1199 svn_wc_context_t *wc_ctx;
1200 svn_wc__db_t *wc_db = svn_wc__adm_get_db(adm_access);
1201 const char *local_abspath;
1203 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1204 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
1206 SVN_ERR(svn_wc_resolved_conflict5(wc_ctx,
1210 resolve_props ? "" : NULL,
1219 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1224 svn_wc_resolved_conflict(const char *path,
1225 svn_wc_adm_access_t *adm_access,
1226 svn_boolean_t resolve_text,
1227 svn_boolean_t resolve_props,
1228 svn_boolean_t recurse,
1229 svn_wc_notify_func_t notify_func,
1233 struct compat_notify_baton_t nb;
1235 nb.func = notify_func;
1236 nb.baton = notify_baton;
1238 return svn_wc_resolved_conflict2(path, adm_access,
1239 resolve_text, resolve_props, recurse,
1240 compat_call_notify_func, &nb,
1246 svn_wc_resolved_conflict2(const char *path,
1247 svn_wc_adm_access_t *adm_access,
1248 svn_boolean_t resolve_text,
1249 svn_boolean_t resolve_props,
1250 svn_boolean_t recurse,
1251 svn_wc_notify_func2_t notify_func,
1253 svn_cancel_func_t cancel_func,
1257 return svn_wc_resolved_conflict3(path, adm_access, resolve_text,
1259 SVN_DEPTH_INFINITY_OR_EMPTY(recurse),
1260 svn_wc_conflict_choose_merged,
1261 notify_func, notify_baton, cancel_func,
1262 cancel_baton, pool);
1266 svn_wc_resolved_conflict3(const char *path,
1267 svn_wc_adm_access_t *adm_access,
1268 svn_boolean_t resolve_text,
1269 svn_boolean_t resolve_props,
1271 svn_wc_conflict_choice_t conflict_choice,
1272 svn_wc_notify_func2_t notify_func,
1274 svn_cancel_func_t cancel_func,
1278 return svn_wc_resolved_conflict4(path, adm_access, resolve_text,
1279 resolve_props, FALSE, depth,
1280 svn_wc_conflict_choose_merged,
1281 notify_func, notify_baton, cancel_func,
1282 cancel_baton, pool);
1286 svn_wc_add_lock(const char *path,
1287 const svn_lock_t *lock,
1288 svn_wc_adm_access_t *adm_access,
1291 const char *local_abspath;
1292 svn_wc_context_t *wc_ctx;
1294 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1295 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
1296 svn_wc__adm_get_db(adm_access),
1299 SVN_ERR(svn_wc_add_lock2(wc_ctx, local_abspath, lock, pool));
1301 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1305 svn_wc_remove_lock(const char *path,
1306 svn_wc_adm_access_t *adm_access,
1309 const char *local_abspath;
1310 svn_wc_context_t *wc_ctx;
1312 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1313 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
1314 svn_wc__adm_get_db(adm_access),
1317 SVN_ERR(svn_wc_remove_lock2(wc_ctx, local_abspath, pool));
1319 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1324 svn_wc_get_ancestry(char **url,
1327 svn_wc_adm_access_t *adm_access,
1330 const char *local_abspath;
1331 const svn_wc_entry_t *entry;
1333 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1335 SVN_ERR(svn_wc__get_entry(&entry, svn_wc__adm_get_db(adm_access),
1336 local_abspath, FALSE,
1341 *url = apr_pstrdup(pool, entry->url);
1344 *rev = entry->revision;
1346 return SVN_NO_ERROR;
1350 svn_wc_set_changelist(const char *path,
1351 const char *changelist,
1352 svn_wc_adm_access_t *adm_access,
1353 svn_cancel_func_t cancel_func,
1355 svn_wc_notify_func2_t notify_func,
1359 const char *local_abspath;
1360 svn_wc_context_t *wc_ctx;
1362 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
1363 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
1364 svn_wc__adm_get_db(adm_access),
1367 SVN_ERR(svn_wc_set_changelist2(wc_ctx, local_abspath, changelist,
1368 svn_depth_empty, NULL,
1369 cancel_func, cancel_baton, notify_func,
1370 notify_baton, pool));
1372 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
1376 /*** From diff.c ***/
1377 /* Used to wrap svn_wc_diff_callbacks_t. */
1378 struct diff_callbacks_wrapper_baton {
1379 const svn_wc_diff_callbacks_t *callbacks;
1383 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1384 static svn_error_t *
1385 wrap_3to1_file_changed(svn_wc_adm_access_t *adm_access,
1386 svn_wc_notify_state_t *contentstate,
1387 svn_wc_notify_state_t *propstate,
1388 svn_boolean_t *tree_conflicted,
1390 const char *tmpfile1,
1391 const char *tmpfile2,
1394 const char *mimetype1,
1395 const char *mimetype2,
1396 const apr_array_header_t *propchanges,
1397 apr_hash_t *originalprops,
1400 struct diff_callbacks_wrapper_baton *b = diff_baton;
1402 if (tree_conflicted)
1403 *tree_conflicted = FALSE;
1405 if (tmpfile2 != NULL)
1406 SVN_ERR(b->callbacks->file_changed(adm_access, contentstate, path,
1408 rev1, rev2, mimetype1, mimetype2,
1410 if (propchanges->nelts > 0)
1411 SVN_ERR(b->callbacks->props_changed(adm_access, propstate, path,
1412 propchanges, originalprops,
1415 return SVN_NO_ERROR;
1418 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1419 static svn_error_t *
1420 wrap_3to1_file_added(svn_wc_adm_access_t *adm_access,
1421 svn_wc_notify_state_t *contentstate,
1422 svn_wc_notify_state_t *propstate,
1423 svn_boolean_t *tree_conflicted,
1425 const char *tmpfile1,
1426 const char *tmpfile2,
1429 const char *mimetype1,
1430 const char *mimetype2,
1431 const apr_array_header_t *propchanges,
1432 apr_hash_t *originalprops,
1435 struct diff_callbacks_wrapper_baton *b = diff_baton;
1437 if (tree_conflicted)
1438 *tree_conflicted = FALSE;
1440 SVN_ERR(b->callbacks->file_added(adm_access, contentstate, path,
1441 tmpfile1, tmpfile2, rev1, rev2,
1442 mimetype1, mimetype2, b->baton));
1443 if (propchanges->nelts > 0)
1444 SVN_ERR(b->callbacks->props_changed(adm_access, propstate, path,
1445 propchanges, originalprops,
1448 return SVN_NO_ERROR;
1451 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1452 static svn_error_t *
1453 wrap_3to1_file_deleted(svn_wc_adm_access_t *adm_access,
1454 svn_wc_notify_state_t *state,
1455 svn_boolean_t *tree_conflicted,
1457 const char *tmpfile1,
1458 const char *tmpfile2,
1459 const char *mimetype1,
1460 const char *mimetype2,
1461 apr_hash_t *originalprops,
1464 struct diff_callbacks_wrapper_baton *b = diff_baton;
1466 if (tree_conflicted)
1467 *tree_conflicted = FALSE;
1469 SVN_ERR_ASSERT(originalprops);
1471 return b->callbacks->file_deleted(adm_access, state, path,
1472 tmpfile1, tmpfile2, mimetype1, mimetype2,
1476 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1477 static svn_error_t *
1478 wrap_3to1_dir_added(svn_wc_adm_access_t *adm_access,
1479 svn_wc_notify_state_t *state,
1480 svn_boolean_t *tree_conflicted,
1485 struct diff_callbacks_wrapper_baton *b = diff_baton;
1487 if (tree_conflicted)
1488 *tree_conflicted = FALSE;
1490 return b->callbacks->dir_added(adm_access, state, path, rev, b->baton);
1493 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1494 static svn_error_t *
1495 wrap_3to1_dir_deleted(svn_wc_adm_access_t *adm_access,
1496 svn_wc_notify_state_t *state,
1497 svn_boolean_t *tree_conflicted,
1501 struct diff_callbacks_wrapper_baton *b = diff_baton;
1503 if (tree_conflicted)
1504 *tree_conflicted = FALSE;
1506 return b->callbacks->dir_deleted(adm_access, state, path, b->baton);
1509 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t. */
1510 static svn_error_t *
1511 wrap_3to1_dir_props_changed(svn_wc_adm_access_t *adm_access,
1512 svn_wc_notify_state_t *state,
1513 svn_boolean_t *tree_conflicted,
1515 const apr_array_header_t *propchanges,
1516 apr_hash_t *originalprops,
1519 struct diff_callbacks_wrapper_baton *b = diff_baton;
1521 if (tree_conflicted)
1522 *tree_conflicted = FALSE;
1524 return b->callbacks->props_changed(adm_access, state, path, propchanges,
1525 originalprops, b->baton);
1528 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t
1529 and svn_wc_diff_callbacks2_t. */
1530 static svn_error_t *
1531 wrap_3to1or2_dir_opened(svn_wc_adm_access_t *adm_access,
1532 svn_boolean_t *tree_conflicted,
1537 if (tree_conflicted)
1538 *tree_conflicted = FALSE;
1540 return SVN_NO_ERROR;
1543 /* An svn_wc_diff_callbacks3_t function for wrapping svn_wc_diff_callbacks_t
1544 and svn_wc_diff_callbacks2_t. */
1545 static svn_error_t *
1546 wrap_3to1or2_dir_closed(svn_wc_adm_access_t *adm_access,
1547 svn_wc_notify_state_t *propstate,
1548 svn_wc_notify_state_t *contentstate,
1549 svn_boolean_t *tree_conflicted,
1554 *contentstate = svn_wc_notify_state_unknown;
1556 *propstate = svn_wc_notify_state_unknown;
1557 if (tree_conflicted)
1558 *tree_conflicted = FALSE;
1560 return SVN_NO_ERROR;
1563 /* Used to wrap svn_diff_callbacks_t as an svn_wc_diff_callbacks3_t. */
1564 static struct svn_wc_diff_callbacks3_t diff_callbacks_wrapper = {
1565 wrap_3to1_file_changed,
1566 wrap_3to1_file_added,
1567 wrap_3to1_file_deleted,
1568 wrap_3to1_dir_added,
1569 wrap_3to1_dir_deleted,
1570 wrap_3to1_dir_props_changed,
1571 wrap_3to1or2_dir_opened,
1572 wrap_3to1or2_dir_closed
1577 /* Used to wrap svn_wc_diff_callbacks2_t. */
1578 struct diff_callbacks2_wrapper_baton {
1579 const svn_wc_diff_callbacks2_t *callbacks2;
1583 /* An svn_wc_diff_callbacks3_t function for wrapping
1584 * svn_wc_diff_callbacks2_t. */
1585 static svn_error_t *
1586 wrap_3to2_file_changed(svn_wc_adm_access_t *adm_access,
1587 svn_wc_notify_state_t *contentstate,
1588 svn_wc_notify_state_t *propstate,
1589 svn_boolean_t *tree_conflicted,
1591 const char *tmpfile1,
1592 const char *tmpfile2,
1595 const char *mimetype1,
1596 const char *mimetype2,
1597 const apr_array_header_t *propchanges,
1598 apr_hash_t *originalprops,
1601 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1603 if (tree_conflicted)
1604 *tree_conflicted = FALSE;
1606 return b->callbacks2->file_changed(adm_access, contentstate, propstate,
1607 path, tmpfile1, tmpfile2,
1608 rev1, rev2, mimetype1, mimetype2,
1609 propchanges, originalprops, b->baton);
1612 /* An svn_wc_diff_callbacks3_t function for wrapping
1613 * svn_wc_diff_callbacks2_t. */
1614 static svn_error_t *
1615 wrap_3to2_file_added(svn_wc_adm_access_t *adm_access,
1616 svn_wc_notify_state_t *contentstate,
1617 svn_wc_notify_state_t *propstate,
1618 svn_boolean_t *tree_conflicted,
1620 const char *tmpfile1,
1621 const char *tmpfile2,
1624 const char *mimetype1,
1625 const char *mimetype2,
1626 const apr_array_header_t *propchanges,
1627 apr_hash_t *originalprops,
1630 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1632 if (tree_conflicted)
1633 *tree_conflicted = FALSE;
1635 return b->callbacks2->file_added(adm_access, contentstate, propstate, path,
1636 tmpfile1, tmpfile2, rev1, rev2,
1637 mimetype1, mimetype2, propchanges,
1638 originalprops, b->baton);
1641 /* An svn_wc_diff_callbacks3_t function for wrapping
1642 * svn_wc_diff_callbacks2_t. */
1643 static svn_error_t *
1644 wrap_3to2_file_deleted(svn_wc_adm_access_t *adm_access,
1645 svn_wc_notify_state_t *state,
1646 svn_boolean_t *tree_conflicted,
1648 const char *tmpfile1,
1649 const char *tmpfile2,
1650 const char *mimetype1,
1651 const char *mimetype2,
1652 apr_hash_t *originalprops,
1655 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1657 if (tree_conflicted)
1658 *tree_conflicted = FALSE;
1660 return b->callbacks2->file_deleted(adm_access, state, path,
1661 tmpfile1, tmpfile2, mimetype1, mimetype2,
1662 originalprops, b->baton);
1665 /* An svn_wc_diff_callbacks3_t function for wrapping
1666 * svn_wc_diff_callbacks2_t. */
1667 static svn_error_t *
1668 wrap_3to2_dir_added(svn_wc_adm_access_t *adm_access,
1669 svn_wc_notify_state_t *state,
1670 svn_boolean_t *tree_conflicted,
1675 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1677 if (tree_conflicted)
1678 *tree_conflicted = FALSE;
1680 return b->callbacks2->dir_added(adm_access, state, path, rev, b->baton);
1683 /* An svn_wc_diff_callbacks3_t function for wrapping
1684 * svn_wc_diff_callbacks2_t. */
1685 static svn_error_t *
1686 wrap_3to2_dir_deleted(svn_wc_adm_access_t *adm_access,
1687 svn_wc_notify_state_t *state,
1688 svn_boolean_t *tree_conflicted,
1692 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1694 if (tree_conflicted)
1695 *tree_conflicted = FALSE;
1697 return b->callbacks2->dir_deleted(adm_access, state, path, b->baton);
1700 /* An svn_wc_diff_callbacks3_t function for wrapping
1701 * svn_wc_diff_callbacks2_t. */
1702 static svn_error_t *
1703 wrap_3to2_dir_props_changed(svn_wc_adm_access_t *adm_access,
1704 svn_wc_notify_state_t *state,
1705 svn_boolean_t *tree_conflicted,
1707 const apr_array_header_t *propchanges,
1708 apr_hash_t *originalprops,
1711 struct diff_callbacks2_wrapper_baton *b = diff_baton;
1713 if (tree_conflicted)
1714 *tree_conflicted = FALSE;
1716 return b->callbacks2->dir_props_changed(adm_access, state, path, propchanges,
1717 originalprops, b->baton);
1720 /* Used to wrap svn_diff_callbacks2_t as an svn_wc_diff_callbacks3_t. */
1721 static struct svn_wc_diff_callbacks3_t diff_callbacks2_wrapper = {
1722 wrap_3to2_file_changed,
1723 wrap_3to2_file_added,
1724 wrap_3to2_file_deleted,
1725 wrap_3to2_dir_added,
1726 wrap_3to2_dir_deleted,
1727 wrap_3to2_dir_props_changed,
1728 wrap_3to1or2_dir_opened,
1729 wrap_3to1or2_dir_closed
1734 /* Used to wrap svn_wc_diff_callbacks3_t. */
1735 struct diff_callbacks3_wrapper_baton {
1736 const svn_wc_diff_callbacks3_t *callbacks3;
1740 const char *anchor_abspath;
1743 static svn_error_t *
1744 wrap_4to3_file_opened(svn_boolean_t *tree_conflicted,
1745 svn_boolean_t *skip,
1749 apr_pool_t *scratch_pool)
1751 return SVN_NO_ERROR;
1754 /* An svn_wc_diff_callbacks4_t function for wrapping
1755 * svn_wc_diff_callbacks3_t. */
1756 static svn_error_t *
1757 wrap_4to3_file_changed(svn_wc_notify_state_t *contentstate,
1758 svn_wc_notify_state_t *propstate,
1759 svn_boolean_t *tree_conflicted,
1761 const char *tmpfile1,
1762 const char *tmpfile2,
1765 const char *mimetype1,
1766 const char *mimetype2,
1767 const apr_array_header_t *propchanges,
1768 apr_hash_t *originalprops,
1770 apr_pool_t *scratch_pool)
1772 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1773 svn_wc_adm_access_t *adm_access;
1774 const char *dir = svn_relpath_dirname(path, scratch_pool);
1776 adm_access = svn_wc__adm_retrieve_internal2(
1778 svn_dirent_join(b->anchor_abspath, dir, scratch_pool),
1781 return b->callbacks3->file_changed(adm_access, contentstate, propstate,
1783 svn_dirent_join(b->anchor, path,
1786 rev1, rev2, mimetype1, mimetype2,
1787 propchanges, originalprops, b->baton);
1790 /* An svn_wc_diff_callbacks4_t function for wrapping
1791 * svn_wc_diff_callbacks3_t. */
1792 static svn_error_t *
1793 wrap_4to3_file_added(svn_wc_notify_state_t *contentstate,
1794 svn_wc_notify_state_t *propstate,
1795 svn_boolean_t *tree_conflicted,
1797 const char *tmpfile1,
1798 const char *tmpfile2,
1801 const char *mimetype1,
1802 const char *mimetype2,
1803 const char *copyfrom_path,
1804 svn_revnum_t copyfrom_revision,
1805 const apr_array_header_t *propchanges,
1806 apr_hash_t *originalprops,
1808 apr_pool_t *scratch_pool)
1810 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1811 svn_wc_adm_access_t *adm_access;
1812 const char *dir = svn_relpath_dirname(path, scratch_pool);
1814 adm_access = svn_wc__adm_retrieve_internal2(
1816 svn_dirent_join(b->anchor_abspath, dir, scratch_pool),
1819 return b->callbacks3->file_added(adm_access, contentstate, propstate,
1821 svn_dirent_join(b->anchor, path,
1824 rev1, rev2, mimetype1, mimetype2,
1825 propchanges, originalprops, b->baton);
1828 /* An svn_wc_diff_callbacks4_t function for wrapping
1829 * svn_wc_diff_callbacks3_t. */
1830 static svn_error_t *
1831 wrap_4to3_file_deleted(svn_wc_notify_state_t *state,
1832 svn_boolean_t *tree_conflicted,
1834 const char *tmpfile1,
1835 const char *tmpfile2,
1836 const char *mimetype1,
1837 const char *mimetype2,
1838 apr_hash_t *originalprops,
1840 apr_pool_t *scratch_pool)
1842 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1843 svn_wc_adm_access_t *adm_access;
1844 const char *dir = svn_relpath_dirname(path, scratch_pool);
1846 adm_access = svn_wc__adm_retrieve_internal2(
1848 svn_dirent_join(b->anchor_abspath, dir, scratch_pool),
1851 return b->callbacks3->file_deleted(adm_access, state, tree_conflicted,
1852 svn_dirent_join(b->anchor, path,
1855 mimetype1, mimetype2, originalprops,
1859 /* An svn_wc_diff_callbacks4_t function for wrapping
1860 * svn_wc_diff_callbacks3_t. */
1861 static svn_error_t *
1862 wrap_4to3_dir_added(svn_wc_notify_state_t *state,
1863 svn_boolean_t *tree_conflicted,
1864 svn_boolean_t *skip,
1865 svn_boolean_t *skip_children,
1868 const char *copyfrom_path,
1869 svn_revnum_t copyfrom_revision,
1871 apr_pool_t *scratch_pool)
1873 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1874 svn_wc_adm_access_t *adm_access;
1876 adm_access = svn_wc__adm_retrieve_internal2(
1878 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
1881 return b->callbacks3->dir_added(adm_access, state, tree_conflicted,
1882 svn_dirent_join(b->anchor, path,
1887 /* An svn_wc_diff_callbacks4_t function for wrapping
1888 * svn_wc_diff_callbacks3_t. */
1889 static svn_error_t *
1890 wrap_4to3_dir_deleted(svn_wc_notify_state_t *state,
1891 svn_boolean_t *tree_conflicted,
1894 apr_pool_t *scratch_pool)
1896 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1897 svn_wc_adm_access_t *adm_access;
1899 adm_access = svn_wc__adm_retrieve_internal2(
1901 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
1904 return b->callbacks3->dir_deleted(adm_access, state, tree_conflicted,
1905 svn_dirent_join(b->anchor, path,
1910 /* An svn_wc_diff_callbacks4_t function for wrapping
1911 * svn_wc_diff_callbacks3_t. */
1912 static svn_error_t *
1913 wrap_4to3_dir_props_changed(svn_wc_notify_state_t *propstate,
1914 svn_boolean_t *tree_conflicted,
1916 svn_boolean_t dir_was_added,
1917 const apr_array_header_t *propchanges,
1918 apr_hash_t *original_props,
1920 apr_pool_t *scratch_pool)
1922 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1923 svn_wc_adm_access_t *adm_access;
1925 adm_access = svn_wc__adm_retrieve_internal2(
1927 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
1930 return b->callbacks3->dir_props_changed(adm_access, propstate,
1932 svn_dirent_join(b->anchor, path,
1934 propchanges, original_props,
1938 /* An svn_wc_diff_callbacks4_t function for wrapping
1939 * svn_wc_diff_callbacks3_t. */
1940 static svn_error_t *
1941 wrap_4to3_dir_opened(svn_boolean_t *tree_conflicted,
1942 svn_boolean_t *skip,
1943 svn_boolean_t *skip_children,
1947 apr_pool_t *scratch_pool)
1949 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1950 svn_wc_adm_access_t *adm_access;
1952 adm_access = svn_wc__adm_retrieve_internal2(
1954 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
1957 *skip_children = FALSE;
1959 return b->callbacks3->dir_opened(adm_access, tree_conflicted,
1960 svn_dirent_join(b->anchor, path,
1965 /* An svn_wc_diff_callbacks4_t function for wrapping
1966 * svn_wc_diff_callbacks3_t. */
1967 static svn_error_t *
1968 wrap_4to3_dir_closed(svn_wc_notify_state_t *contentstate,
1969 svn_wc_notify_state_t *propstate,
1970 svn_boolean_t *tree_conflicted,
1972 svn_boolean_t dir_was_added,
1974 apr_pool_t *scratch_pool)
1976 struct diff_callbacks3_wrapper_baton *b = diff_baton;
1977 svn_wc_adm_access_t *adm_access;
1979 adm_access = svn_wc__adm_retrieve_internal2(
1981 svn_dirent_join(b->anchor_abspath, path, scratch_pool),
1984 return b->callbacks3->dir_closed(adm_access, contentstate, propstate,
1986 svn_dirent_join(b->anchor, path,
1992 /* Used to wrap svn_diff_callbacks3_t as an svn_wc_diff_callbacks4_t. */
1993 static struct svn_wc_diff_callbacks4_t diff_callbacks3_wrapper = {
1994 wrap_4to3_file_opened,
1995 wrap_4to3_file_changed,
1996 wrap_4to3_file_added,
1997 wrap_4to3_file_deleted,
1998 wrap_4to3_dir_deleted,
1999 wrap_4to3_dir_opened,
2000 wrap_4to3_dir_added,
2001 wrap_4to3_dir_props_changed,
2002 wrap_4to3_dir_closed
2007 svn_wc_get_diff_editor6(const svn_delta_editor_t **editor,
2009 svn_wc_context_t *wc_ctx,
2010 const char *anchor_abspath,
2013 svn_boolean_t ignore_ancestry,
2014 svn_boolean_t show_copies_as_adds,
2015 svn_boolean_t use_git_diff_format,
2016 svn_boolean_t use_text_base,
2017 svn_boolean_t reverse_order,
2018 svn_boolean_t server_performs_filtering,
2019 const apr_array_header_t *changelist_filter,
2020 const svn_wc_diff_callbacks4_t *callbacks,
2021 void *callback_baton,
2022 svn_cancel_func_t cancel_func,
2024 apr_pool_t *result_pool,
2025 apr_pool_t *scratch_pool)
2027 const svn_diff_tree_processor_t *diff_processor;
2029 /* --git implies --show-copies-as-adds */
2030 if (use_git_diff_format)
2031 show_copies_as_adds = TRUE;
2033 /* --show-copies-as-adds implies --notice-ancestry */
2034 if (show_copies_as_adds)
2035 ignore_ancestry = FALSE;
2037 SVN_ERR(svn_wc__wrap_diff_callbacks(&diff_processor,
2038 callbacks, callback_baton, TRUE,
2039 result_pool, scratch_pool));
2042 diff_processor = svn_diff__tree_processor_reverse_create(
2043 diff_processor, NULL, result_pool);
2045 if (! show_copies_as_adds)
2046 diff_processor = svn_diff__tree_processor_copy_as_changed_create(
2047 diff_processor, result_pool);
2049 return svn_error_trace(
2050 svn_wc__get_diff_editor(editor, edit_baton,
2052 anchor_abspath, target,
2054 ignore_ancestry, use_text_base,
2055 reverse_order, server_performs_filtering,
2058 cancel_func, cancel_baton,
2059 result_pool, scratch_pool));
2064 svn_wc_get_diff_editor5(svn_wc_adm_access_t *anchor,
2066 const svn_wc_diff_callbacks3_t *callbacks,
2067 void *callback_baton,
2069 svn_boolean_t ignore_ancestry,
2070 svn_boolean_t use_text_base,
2071 svn_boolean_t reverse_order,
2072 svn_cancel_func_t cancel_func,
2074 const apr_array_header_t *changelist_filter,
2075 const svn_delta_editor_t **editor,
2079 struct diff_callbacks3_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2080 svn_wc_context_t *wc_ctx;
2081 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
2083 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
2085 b->callbacks3 = callbacks;
2086 b->baton = callback_baton;
2088 b->anchor = svn_wc_adm_access_path(anchor);
2089 b->anchor_abspath = svn_wc__adm_access_abspath(anchor);
2091 SVN_ERR(svn_wc_get_diff_editor6(editor,
2104 &diff_callbacks3_wrapper,
2111 /* Can't destroy wc_ctx. It is used by the diff editor */
2113 return SVN_NO_ERROR;
2117 svn_wc_get_diff_editor4(svn_wc_adm_access_t *anchor,
2119 const svn_wc_diff_callbacks2_t *callbacks,
2120 void *callback_baton,
2122 svn_boolean_t ignore_ancestry,
2123 svn_boolean_t use_text_base,
2124 svn_boolean_t reverse_order,
2125 svn_cancel_func_t cancel_func,
2127 const apr_array_header_t *changelist_filter,
2128 const svn_delta_editor_t **editor,
2132 struct diff_callbacks2_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2133 b->callbacks2 = callbacks;
2134 b->baton = callback_baton;
2135 return svn_wc_get_diff_editor5(anchor,
2137 &diff_callbacks2_wrapper,
2152 svn_wc_get_diff_editor3(svn_wc_adm_access_t *anchor,
2154 const svn_wc_diff_callbacks2_t *callbacks,
2155 void *callback_baton,
2156 svn_boolean_t recurse,
2157 svn_boolean_t ignore_ancestry,
2158 svn_boolean_t use_text_base,
2159 svn_boolean_t reverse_order,
2160 svn_cancel_func_t cancel_func,
2162 const svn_delta_editor_t **editor,
2166 return svn_wc_get_diff_editor4(anchor,
2170 SVN_DEPTH_INFINITY_OR_FILES(recurse),
2183 svn_wc_get_diff_editor2(svn_wc_adm_access_t *anchor,
2185 const svn_wc_diff_callbacks_t *callbacks,
2186 void *callback_baton,
2187 svn_boolean_t recurse,
2188 svn_boolean_t ignore_ancestry,
2189 svn_boolean_t use_text_base,
2190 svn_boolean_t reverse_order,
2191 svn_cancel_func_t cancel_func,
2193 const svn_delta_editor_t **editor,
2197 struct diff_callbacks_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2198 b->callbacks = callbacks;
2199 b->baton = callback_baton;
2200 return svn_wc_get_diff_editor5(anchor, target, &diff_callbacks_wrapper, b,
2201 SVN_DEPTH_INFINITY_OR_FILES(recurse),
2202 ignore_ancestry, use_text_base,
2203 reverse_order, cancel_func, cancel_baton,
2204 NULL, editor, edit_baton, pool);
2208 svn_wc_get_diff_editor(svn_wc_adm_access_t *anchor,
2210 const svn_wc_diff_callbacks_t *callbacks,
2211 void *callback_baton,
2212 svn_boolean_t recurse,
2213 svn_boolean_t use_text_base,
2214 svn_boolean_t reverse_order,
2215 svn_cancel_func_t cancel_func,
2217 const svn_delta_editor_t **editor,
2221 return svn_wc_get_diff_editor2(anchor, target, callbacks, callback_baton,
2222 recurse, FALSE, use_text_base, reverse_order,
2223 cancel_func, cancel_baton,
2224 editor, edit_baton, pool);
2228 svn_wc_diff5(svn_wc_adm_access_t *anchor,
2230 const svn_wc_diff_callbacks3_t *callbacks,
2231 void *callback_baton,
2233 svn_boolean_t ignore_ancestry,
2234 const apr_array_header_t *changelist_filter,
2237 struct diff_callbacks3_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2238 svn_wc_context_t *wc_ctx;
2239 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
2241 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
2243 b->callbacks3 = callbacks;
2244 b->baton = callback_baton;
2245 b->anchor = svn_wc_adm_access_path(anchor);
2246 b->anchor_abspath = svn_wc__adm_access_abspath(anchor);
2248 SVN_ERR(svn_wc_diff6(wc_ctx,
2249 svn_dirent_join(b->anchor_abspath, target, pool),
2250 &diff_callbacks3_wrapper,
2260 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
2264 svn_wc_diff4(svn_wc_adm_access_t *anchor,
2266 const svn_wc_diff_callbacks2_t *callbacks,
2267 void *callback_baton,
2269 svn_boolean_t ignore_ancestry,
2270 const apr_array_header_t *changelist_filter,
2273 struct diff_callbacks2_wrapper_baton *b = apr_palloc(pool, sizeof(*b));
2274 b->callbacks2 = callbacks;
2275 b->baton = callback_baton;
2277 return svn_wc_diff5(anchor, target, &diff_callbacks2_wrapper, b,
2278 depth, ignore_ancestry, changelist_filter, pool);
2282 svn_wc_diff3(svn_wc_adm_access_t *anchor,
2284 const svn_wc_diff_callbacks2_t *callbacks,
2285 void *callback_baton,
2286 svn_boolean_t recurse,
2287 svn_boolean_t ignore_ancestry,
2290 return svn_wc_diff4(anchor, target, callbacks, callback_baton,
2291 SVN_DEPTH_INFINITY_OR_FILES(recurse), ignore_ancestry,
2296 svn_wc_diff2(svn_wc_adm_access_t *anchor,
2298 const svn_wc_diff_callbacks_t *callbacks,
2299 void *callback_baton,
2300 svn_boolean_t recurse,
2301 svn_boolean_t ignore_ancestry,
2304 struct diff_callbacks_wrapper_baton *b = apr_pcalloc(pool, sizeof(*b));
2305 b->callbacks = callbacks;
2306 b->baton = callback_baton;
2307 return svn_wc_diff5(anchor, target, &diff_callbacks_wrapper, b,
2308 SVN_DEPTH_INFINITY_OR_FILES(recurse), ignore_ancestry,
2313 svn_wc_diff(svn_wc_adm_access_t *anchor,
2315 const svn_wc_diff_callbacks_t *callbacks,
2316 void *callback_baton,
2317 svn_boolean_t recurse,
2320 return svn_wc_diff2(anchor, target, callbacks, callback_baton,
2321 recurse, FALSE, pool);
2324 /*** From entries.c ***/
2326 svn_wc_walk_entries2(const char *path,
2327 svn_wc_adm_access_t *adm_access,
2328 const svn_wc_entry_callbacks_t *walk_callbacks,
2330 svn_boolean_t show_hidden,
2331 svn_cancel_func_t cancel_func,
2335 svn_wc_entry_callbacks2_t walk_cb2 = { 0 };
2336 walk_cb2.found_entry = walk_callbacks->found_entry;
2337 walk_cb2.handle_error = svn_wc__walker_default_error_handler;
2338 return svn_wc_walk_entries3(path, adm_access,
2339 &walk_cb2, walk_baton, svn_depth_infinity,
2340 show_hidden, cancel_func, cancel_baton, pool);
2344 svn_wc_walk_entries(const char *path,
2345 svn_wc_adm_access_t *adm_access,
2346 const svn_wc_entry_callbacks_t *walk_callbacks,
2348 svn_boolean_t show_hidden,
2351 return svn_wc_walk_entries2(path, adm_access, walk_callbacks,
2352 walk_baton, show_hidden, NULL, NULL,
2357 svn_wc_mark_missing_deleted(const char *path,
2358 svn_wc_adm_access_t *parent,
2361 /* With a single DB a node will never be missing */
2362 return svn_error_createf(SVN_ERR_WC_PATH_FOUND, NULL,
2363 _("Unexpectedly found '%s': "
2364 "path is marked 'missing'"),
2365 svn_dirent_local_style(path, pool));
2369 /*** From props.c ***/
2371 svn_wc_parse_externals_description2(apr_array_header_t **externals_p,
2372 const char *parent_directory,
2376 apr_array_header_t *list;
2377 apr_pool_t *subpool = svn_pool_create(pool);
2379 SVN_ERR(svn_wc_parse_externals_description3(externals_p ? &list : NULL,
2380 parent_directory, desc,
2387 *externals_p = apr_array_make(pool, list->nelts,
2388 sizeof(svn_wc_external_item_t *));
2389 for (i = 0; i < list->nelts; i++)
2391 svn_wc_external_item2_t *item2 = APR_ARRAY_IDX(list, i,
2392 svn_wc_external_item2_t *);
2393 svn_wc_external_item_t *item = apr_palloc(pool, sizeof (*item));
2395 if (item2->target_dir)
2396 item->target_dir = apr_pstrdup(pool, item2->target_dir);
2398 item->url = apr_pstrdup(pool, item2->url);
2399 item->revision = item2->revision;
2401 APR_ARRAY_PUSH(*externals_p, svn_wc_external_item_t *) = item;
2405 svn_pool_destroy(subpool);
2407 return SVN_NO_ERROR;
2412 svn_wc_parse_externals_description(apr_hash_t **externals_p,
2413 const char *parent_directory,
2417 apr_array_header_t *list;
2419 SVN_ERR(svn_wc_parse_externals_description2(externals_p ? &list : NULL,
2420 parent_directory, desc, pool));
2422 /* Store all of the items into the hash if that was requested. */
2427 *externals_p = apr_hash_make(pool);
2428 for (i = 0; i < list->nelts; i++)
2430 svn_wc_external_item_t *item;
2431 item = APR_ARRAY_IDX(list, i, svn_wc_external_item_t *);
2433 svn_hash_sets(*externals_p, item->target_dir, item);
2436 return SVN_NO_ERROR;
2440 svn_wc_prop_set3(const char *name,
2441 const svn_string_t *value,
2443 svn_wc_adm_access_t *adm_access,
2444 svn_boolean_t skip_checks,
2445 svn_wc_notify_func2_t notify_func,
2449 svn_wc_context_t *wc_ctx;
2450 const char *local_abspath;
2453 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2454 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2455 svn_wc__adm_get_db(adm_access),
2458 err = svn_wc_prop_set4(wc_ctx, local_abspath,
2461 skip_checks, NULL /* changelist_filter */,
2462 NULL, NULL /* cancellation */,
2463 notify_func, notify_baton,
2466 if (err && err->apr_err == SVN_ERR_WC_INVALID_SCHEDULE)
2467 svn_error_clear(err);
2471 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
2475 svn_wc_prop_set2(const char *name,
2476 const svn_string_t *value,
2478 svn_wc_adm_access_t *adm_access,
2479 svn_boolean_t skip_checks,
2482 return svn_wc_prop_set3(name, value, path, adm_access, skip_checks,
2487 svn_wc_prop_set(const char *name,
2488 const svn_string_t *value,
2490 svn_wc_adm_access_t *adm_access,
2493 return svn_wc_prop_set2(name, value, path, adm_access, FALSE, pool);
2497 svn_wc_prop_list(apr_hash_t **props,
2499 svn_wc_adm_access_t *adm_access,
2502 svn_wc_context_t *wc_ctx;
2503 const char *local_abspath;
2506 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2507 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2508 svn_wc__adm_get_db(adm_access), pool));
2510 err = svn_wc_prop_list2(props, wc_ctx, local_abspath, pool, pool);
2511 if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
2513 *props = apr_hash_make(pool);
2514 svn_error_clear(err);
2518 return svn_error_compose_create(err, svn_wc_context_destroy(wc_ctx));
2522 svn_wc_prop_get(const svn_string_t **value,
2525 svn_wc_adm_access_t *adm_access,
2529 svn_wc_context_t *wc_ctx;
2530 const char *local_abspath;
2533 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2534 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2535 svn_wc__adm_get_db(adm_access), pool));
2537 err = svn_wc_prop_get2(value, wc_ctx, local_abspath, name, pool, pool);
2539 if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
2542 svn_error_clear(err);
2546 return svn_error_compose_create(err, svn_wc_context_destroy(wc_ctx));
2549 /* baton for conflict_func_1to2_wrapper */
2550 struct conflict_func_1to2_baton
2552 svn_wc_conflict_resolver_func_t inner_func;
2557 /* Implements svn_wc_conflict_resolver_func2_t */
2558 static svn_error_t *
2559 conflict_func_1to2_wrapper(svn_wc_conflict_result_t **result,
2560 const svn_wc_conflict_description2_t *conflict,
2562 apr_pool_t *result_pool,
2563 apr_pool_t *scratch_pool)
2565 struct conflict_func_1to2_baton *btn = baton;
2566 svn_wc_conflict_description_t *cd = svn_wc__cd2_to_cd(conflict,
2569 return svn_error_trace(btn->inner_func(result, cd, btn->inner_baton,
2574 svn_wc_merge_props2(svn_wc_notify_state_t *state,
2576 svn_wc_adm_access_t *adm_access,
2577 apr_hash_t *baseprops,
2578 const apr_array_header_t *propchanges,
2579 svn_boolean_t base_merge,
2580 svn_boolean_t dry_run,
2581 svn_wc_conflict_resolver_func_t conflict_func,
2582 void *conflict_baton,
2583 apr_pool_t *scratch_pool)
2585 const char *local_abspath;
2587 svn_wc_context_t *wc_ctx;
2588 struct conflict_func_1to2_baton conflict_wrapper;
2590 if (base_merge && !dry_run)
2591 return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
2592 U_("base_merge=TRUE is no longer supported; "
2593 "see notes/api-errata/1.7/wc006.txt"));
2595 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, scratch_pool));
2597 conflict_wrapper.inner_func = conflict_func;
2598 conflict_wrapper.inner_baton = conflict_baton;
2600 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
2601 svn_wc__adm_get_db(adm_access),
2604 err = svn_wc_merge_props3(state,
2607 NULL /* left_version */,
2608 NULL /* right_version */,
2612 conflict_func ? conflict_func_1to2_wrapper
2619 switch(err->apr_err)
2621 case SVN_ERR_WC_PATH_NOT_FOUND:
2622 case SVN_ERR_WC_PATH_UNEXPECTED_STATUS:
2623 err->apr_err = SVN_ERR_UNVERSIONED_RESOURCE;
2626 return svn_error_trace(
2627 svn_error_compose_create(err,
2628 svn_wc_context_destroy(wc_ctx)));
2632 svn_wc_merge_props(svn_wc_notify_state_t *state,
2634 svn_wc_adm_access_t *adm_access,
2635 apr_hash_t *baseprops,
2636 const apr_array_header_t *propchanges,
2637 svn_boolean_t base_merge,
2638 svn_boolean_t dry_run,
2641 return svn_wc_merge_props2(state, path, adm_access, baseprops, propchanges,
2642 base_merge, dry_run, NULL, NULL, pool);
2647 svn_wc_merge_prop_diffs(svn_wc_notify_state_t *state,
2649 svn_wc_adm_access_t *adm_access,
2650 const apr_array_header_t *propchanges,
2651 svn_boolean_t base_merge,
2652 svn_boolean_t dry_run,
2655 /* NOTE: Here, we use implementation knowledge. The public
2656 svn_wc_merge_props2 doesn't allow NULL as baseprops argument, but we know
2658 return svn_wc_merge_props2(state, path, adm_access, NULL, propchanges,
2659 base_merge, dry_run, NULL, NULL, pool);
2663 svn_wc_get_prop_diffs(apr_array_header_t **propchanges,
2664 apr_hash_t **original_props,
2666 svn_wc_adm_access_t *adm_access,
2669 svn_wc_context_t *wc_ctx;
2670 const char *local_abspath;
2672 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2673 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2674 svn_wc__adm_get_db(adm_access), pool));
2676 SVN_ERR(svn_wc_get_prop_diffs2(propchanges, original_props, wc_ctx,
2677 local_abspath, pool, pool));
2679 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
2684 svn_wc_props_modified_p(svn_boolean_t *modified_p,
2686 svn_wc_adm_access_t *adm_access,
2689 svn_wc_context_t *wc_ctx;
2690 const char *local_abspath;
2693 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
2694 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2695 svn_wc__adm_get_db(adm_access), pool));
2697 err = svn_wc_props_modified_p2(modified_p,
2704 if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
2705 return svn_error_trace(err);
2707 svn_error_clear(err);
2708 *modified_p = FALSE;
2711 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
2716 svn_wc__status2_from_3(svn_wc_status2_t **status,
2717 const svn_wc_status3_t *old_status,
2718 svn_wc_context_t *wc_ctx,
2719 const char *local_abspath,
2720 apr_pool_t *result_pool,
2721 apr_pool_t *scratch_pool)
2723 const svn_wc_entry_t *entry = NULL;
2725 if (old_status == NULL)
2728 return SVN_NO_ERROR;
2731 *status = apr_pcalloc(result_pool, sizeof(**status));
2733 if (old_status->versioned)
2736 err= svn_wc__get_entry(&entry, wc_ctx->db, local_abspath, FALSE,
2737 svn_node_unknown, result_pool, scratch_pool);
2739 if (err && err->apr_err == SVN_ERR_NODE_UNEXPECTED_KIND)
2740 svn_error_clear(err);
2745 (*status)->entry = entry;
2746 (*status)->copied = old_status->copied;
2747 (*status)->repos_lock = svn_lock_dup(old_status->repos_lock, result_pool);
2749 if (old_status->repos_relpath)
2750 (*status)->url = svn_path_url_add_component2(old_status->repos_root_url,
2751 old_status->repos_relpath,
2753 (*status)->ood_last_cmt_rev = old_status->ood_changed_rev;
2754 (*status)->ood_last_cmt_date = old_status->ood_changed_date;
2755 (*status)->ood_kind = old_status->ood_kind;
2756 (*status)->ood_last_cmt_author = old_status->ood_changed_author;
2758 if (old_status->conflicted)
2760 const svn_wc_conflict_description2_t *tree_conflict2;
2761 SVN_ERR(svn_wc__get_tree_conflict(&tree_conflict2, wc_ctx, local_abspath,
2762 scratch_pool, scratch_pool));
2763 (*status)->tree_conflict = svn_wc__cd2_to_cd(tree_conflict2, result_pool);
2766 (*status)->switched = old_status->switched;
2768 (*status)->text_status = old_status->node_status;
2769 (*status)->prop_status = old_status->prop_status;
2771 (*status)->repos_text_status = old_status->repos_node_status;
2772 (*status)->repos_prop_status = old_status->repos_prop_status;
2774 /* Some values might be inherited from properties */
2775 if (old_status->node_status == svn_wc_status_modified
2776 || old_status->node_status == svn_wc_status_conflicted)
2777 (*status)->text_status = old_status->text_status;
2779 /* (Currently a no-op, but just make sure it is ok) */
2780 if (old_status->repos_node_status == svn_wc_status_modified
2781 || old_status->repos_node_status == svn_wc_status_conflicted)
2782 (*status)->repos_text_status = old_status->repos_text_status;
2784 if (old_status->node_status == svn_wc_status_added)
2785 (*status)->prop_status = svn_wc_status_none; /* No separate info */
2787 /* Find pristine_text_status value */
2788 switch (old_status->text_status)
2790 case svn_wc_status_none:
2791 case svn_wc_status_normal:
2792 case svn_wc_status_modified:
2793 (*status)->pristine_text_status = old_status->text_status;
2795 case svn_wc_status_conflicted:
2797 /* ### Fetch compare data, or fall back to the documented
2798 not retrieved behavior? */
2799 (*status)->pristine_text_status = svn_wc_status_none;
2803 /* Find pristine_prop_status value */
2804 switch (old_status->prop_status)
2806 case svn_wc_status_none:
2807 case svn_wc_status_normal:
2808 case svn_wc_status_modified:
2809 if (old_status->node_status != svn_wc_status_added
2810 && old_status->node_status != svn_wc_status_deleted
2811 && old_status->node_status != svn_wc_status_replaced)
2813 (*status)->pristine_prop_status = old_status->prop_status;
2816 (*status)->pristine_prop_status = svn_wc_status_none;
2818 case svn_wc_status_conflicted:
2820 /* ### Fetch compare data, or fall back to the documented
2821 not retrieved behavior? */
2822 (*status)->pristine_prop_status = svn_wc_status_none;
2826 if (old_status->versioned
2827 && old_status->conflicted
2828 && old_status->node_status != svn_wc_status_obstructed
2829 && (old_status->kind == svn_node_file
2830 || old_status->node_status != svn_wc_status_missing))
2832 svn_boolean_t text_conflict_p, prop_conflict_p;
2834 /* The entry says there was a conflict, but the user might have
2835 marked it as resolved by deleting the artifact files, so check
2837 SVN_ERR(svn_wc__internal_conflicted_p(&text_conflict_p,
2840 wc_ctx->db, local_abspath,
2843 if (text_conflict_p)
2844 (*status)->text_status = svn_wc_status_conflicted;
2846 if (prop_conflict_p)
2847 (*status)->prop_status = svn_wc_status_conflicted;
2850 return SVN_NO_ERROR;
2855 /*** From status.c ***/
2857 struct status4_wrapper_baton
2859 svn_wc_status_func3_t old_func;
2861 const char *anchor_abspath;
2862 const char *anchor_relpath;
2863 svn_wc_context_t *wc_ctx;
2867 static svn_error_t *
2868 status4_wrapper_func(void *baton,
2869 const char *local_abspath,
2870 const svn_wc_status3_t *status,
2871 apr_pool_t *scratch_pool)
2873 struct status4_wrapper_baton *swb = baton;
2874 svn_wc_status2_t *dup;
2875 const char *path = local_abspath;
2877 SVN_ERR(svn_wc__status2_from_3(&dup, status, swb->wc_ctx, local_abspath,
2878 scratch_pool, scratch_pool));
2880 if (swb->anchor_abspath != NULL)
2882 path = svn_dirent_join(
2883 swb->anchor_relpath,
2884 svn_dirent_skip_ancestor(swb->anchor_abspath, local_abspath),
2888 return (*swb->old_func)(swb->old_baton, path, dup, scratch_pool);
2893 svn_wc_get_status_editor5(const svn_delta_editor_t **editor,
2895 void **set_locks_baton,
2896 svn_revnum_t *edit_revision,
2897 svn_wc_context_t *wc_ctx,
2898 const char *anchor_abspath,
2899 const char *target_basename,
2901 svn_boolean_t get_all,
2902 svn_boolean_t no_ignore,
2903 svn_boolean_t depth_as_sticky,
2904 svn_boolean_t server_performs_filtering,
2905 const apr_array_header_t *ignore_patterns,
2906 svn_wc_status_func4_t status_func,
2908 svn_cancel_func_t cancel_func,
2910 apr_pool_t *result_pool,
2911 apr_pool_t *scratch_pool)
2913 return svn_error_trace(
2914 svn_wc__get_status_editor(editor, edit_baton,
2921 TRUE, /* check_working_copy */
2922 no_ignore, depth_as_sticky,
2923 server_performs_filtering,
2925 status_func, status_baton,
2926 cancel_func, cancel_baton,
2933 svn_wc_get_status_editor4(const svn_delta_editor_t **editor,
2935 void **set_locks_baton,
2936 svn_revnum_t *edit_revision,
2937 svn_wc_adm_access_t *anchor,
2940 svn_boolean_t get_all,
2941 svn_boolean_t no_ignore,
2942 const apr_array_header_t *ignore_patterns,
2943 svn_wc_status_func3_t status_func,
2945 svn_cancel_func_t cancel_func,
2947 svn_wc_traversal_info_t *traversal_info,
2950 struct status4_wrapper_baton *swb = apr_palloc(pool, sizeof(*swb));
2951 svn_wc__db_t *wc_db;
2952 svn_wc_context_t *wc_ctx;
2953 const char *anchor_abspath;
2955 swb->old_func = status_func;
2956 swb->old_baton = status_baton;
2958 wc_db = svn_wc__adm_get_db(anchor);
2960 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
2963 swb->wc_ctx = wc_ctx;
2965 anchor_abspath = svn_wc__adm_access_abspath(anchor);
2967 if (!svn_dirent_is_absolute(svn_wc_adm_access_path(anchor)))
2969 swb->anchor_abspath = anchor_abspath;
2970 swb->anchor_relpath = svn_wc_adm_access_path(anchor);
2974 swb->anchor_abspath = NULL;
2975 swb->anchor_relpath = NULL;
2978 /* Before subversion 1.7 status always handled depth as sticky. 1.7 made
2979 the output of svn status by default match the result of what would be
2980 updated by a similar svn update. (Following the documentation) */
2982 SVN_ERR(svn_wc_get_status_editor5(editor, edit_baton, set_locks_baton,
2983 edit_revision, wc_ctx, anchor_abspath,
2984 target, depth, get_all,
2986 (depth != svn_depth_unknown) /*as_sticky*/,
2987 FALSE /* server_performs_filtering */,
2989 status4_wrapper_func, swb,
2990 cancel_func, cancel_baton,
2995 const char *local_path = svn_wc_adm_access_path(anchor);
2996 const char *local_abspath = anchor_abspath;
2999 local_path = svn_dirent_join(local_path, target, pool);
3000 local_abspath = svn_dirent_join(local_abspath, target, pool);
3003 SVN_ERR(gather_traversal_info(wc_ctx, local_abspath, local_path, depth,
3004 traversal_info, TRUE, TRUE,
3008 /* We can't destroy wc_ctx here, because the editor needs it while it's
3010 return SVN_NO_ERROR;
3013 struct status_editor3_compat_baton
3015 svn_wc_status_func2_t old_func;
3020 static svn_error_t *
3021 status_editor3_compat_func(void *baton,
3023 svn_wc_status2_t *status,
3026 struct status_editor3_compat_baton *secb = baton;
3028 secb->old_func(secb->old_baton, path, status);
3029 return SVN_NO_ERROR;
3033 svn_wc_get_status_editor3(const svn_delta_editor_t **editor,
3035 void **set_locks_baton,
3036 svn_revnum_t *edit_revision,
3037 svn_wc_adm_access_t *anchor,
3040 svn_boolean_t get_all,
3041 svn_boolean_t no_ignore,
3042 const apr_array_header_t *ignore_patterns,
3043 svn_wc_status_func2_t status_func,
3045 svn_cancel_func_t cancel_func,
3047 svn_wc_traversal_info_t *traversal_info,
3050 /* This baton must live beyond this function. Alloc on heap. */
3051 struct status_editor3_compat_baton *secb = apr_palloc(pool, sizeof(*secb));
3053 secb->old_func = status_func;
3054 secb->old_baton = status_baton;
3056 return svn_wc_get_status_editor4(editor, edit_baton, set_locks_baton,
3057 edit_revision, anchor, target, depth,
3058 get_all, no_ignore, ignore_patterns,
3059 status_editor3_compat_func, secb,
3060 cancel_func, cancel_baton, traversal_info,
3065 svn_wc_get_status_editor2(const svn_delta_editor_t **editor,
3067 void **set_locks_baton,
3068 svn_revnum_t *edit_revision,
3069 svn_wc_adm_access_t *anchor,
3072 svn_boolean_t recurse,
3073 svn_boolean_t get_all,
3074 svn_boolean_t no_ignore,
3075 svn_wc_status_func2_t status_func,
3077 svn_cancel_func_t cancel_func,
3079 svn_wc_traversal_info_t *traversal_info,
3082 apr_array_header_t *ignores;
3084 SVN_ERR(svn_wc_get_default_ignores(&ignores, config, pool));
3085 return svn_wc_get_status_editor3(editor,
3091 SVN_DEPTH_INFINITY_OR_IMMEDIATES(recurse),
3104 /* Helpers for deprecated svn_wc_status_editor(), of type
3105 svn_wc_status_func2_t. */
3106 struct old_status_func_cb_baton
3108 svn_wc_status_func_t original_func;
3109 void *original_baton;
3113 static void old_status_func_cb(void *baton,
3115 svn_wc_status2_t *status)
3117 struct old_status_func_cb_baton *b = baton;
3118 svn_wc_status_t *stat = (svn_wc_status_t *) status;
3120 b->original_func(b->original_baton, path, stat);
3124 svn_wc_get_status_editor(const svn_delta_editor_t **editor,
3126 svn_revnum_t *edit_revision,
3127 svn_wc_adm_access_t *anchor,
3130 svn_boolean_t recurse,
3131 svn_boolean_t get_all,
3132 svn_boolean_t no_ignore,
3133 svn_wc_status_func_t status_func,
3135 svn_cancel_func_t cancel_func,
3137 svn_wc_traversal_info_t *traversal_info,
3140 struct old_status_func_cb_baton *b = apr_pcalloc(pool, sizeof(*b));
3141 apr_array_header_t *ignores;
3142 b->original_func = status_func;
3143 b->original_baton = status_baton;
3144 SVN_ERR(svn_wc_get_default_ignores(&ignores, config, pool));
3145 return svn_wc_get_status_editor3(editor, edit_baton, NULL, edit_revision,
3147 SVN_DEPTH_INFINITY_OR_IMMEDIATES(recurse),
3148 get_all, no_ignore, ignores,
3149 old_status_func_cb, b,
3150 cancel_func, cancel_baton,
3151 traversal_info, pool);
3155 svn_wc_status(svn_wc_status_t **status,
3157 svn_wc_adm_access_t *adm_access,
3160 svn_wc_status2_t *stat2;
3162 SVN_ERR(svn_wc_status2(&stat2, path, adm_access, pool));
3163 *status = (svn_wc_status_t *) stat2;
3164 return SVN_NO_ERROR;
3168 static svn_wc_conflict_description_t *
3169 conflict_description_dup(const svn_wc_conflict_description_t *conflict,
3172 svn_wc_conflict_description_t *new_conflict;
3174 new_conflict = apr_pcalloc(pool, sizeof(*new_conflict));
3176 /* Shallow copy all members. */
3177 *new_conflict = *conflict;
3180 new_conflict->path = apr_pstrdup(pool, conflict->path);
3181 if (conflict->property_name)
3182 new_conflict->property_name = apr_pstrdup(pool, conflict->property_name);
3183 if (conflict->mime_type)
3184 new_conflict->mime_type = apr_pstrdup(pool, conflict->mime_type);
3185 /* NOTE: We cannot make a deep copy of adm_access. */
3186 if (conflict->base_file)
3187 new_conflict->base_file = apr_pstrdup(pool, conflict->base_file);
3188 if (conflict->their_file)
3189 new_conflict->their_file = apr_pstrdup(pool, conflict->their_file);
3190 if (conflict->my_file)
3191 new_conflict->my_file = apr_pstrdup(pool, conflict->my_file);
3192 if (conflict->merged_file)
3193 new_conflict->merged_file = apr_pstrdup(pool, conflict->merged_file);
3194 if (conflict->src_left_version)
3195 new_conflict->src_left_version =
3196 svn_wc_conflict_version_dup(conflict->src_left_version, pool);
3197 if (conflict->src_right_version)
3198 new_conflict->src_right_version =
3199 svn_wc_conflict_version_dup(conflict->src_right_version, pool);
3201 return new_conflict;
3206 svn_wc_dup_status2(const svn_wc_status2_t *orig_stat,
3209 svn_wc_status2_t *new_stat = apr_palloc(pool, sizeof(*new_stat));
3211 /* Shallow copy all members. */
3212 *new_stat = *orig_stat;
3214 /* Now go back and dup the deep items into this pool. */
3215 if (orig_stat->entry)
3216 new_stat->entry = svn_wc_entry_dup(orig_stat->entry, pool);
3218 if (orig_stat->repos_lock)
3219 new_stat->repos_lock = svn_lock_dup(orig_stat->repos_lock, pool);
3222 new_stat->url = apr_pstrdup(pool, orig_stat->url);
3224 if (orig_stat->ood_last_cmt_author)
3225 new_stat->ood_last_cmt_author
3226 = apr_pstrdup(pool, orig_stat->ood_last_cmt_author);
3228 if (orig_stat->tree_conflict)
3229 new_stat->tree_conflict
3230 = conflict_description_dup(orig_stat->tree_conflict, pool);
3232 /* Return the new hotness. */
3237 svn_wc_dup_status(const svn_wc_status_t *orig_stat,
3240 svn_wc_status_t *new_stat = apr_palloc(pool, sizeof(*new_stat));
3242 /* Shallow copy all members. */
3243 *new_stat = *orig_stat;
3245 /* Now go back and dup the deep item into this pool. */
3246 if (orig_stat->entry)
3247 new_stat->entry = svn_wc_entry_dup(orig_stat->entry, pool);
3249 /* Return the new hotness. */
3254 svn_wc_get_ignores(apr_array_header_t **patterns,
3256 svn_wc_adm_access_t *adm_access,
3259 svn_wc_context_t *wc_ctx;
3260 const char *local_abspath;
3262 SVN_ERR(svn_dirent_get_absolute(&local_abspath,
3263 svn_wc_adm_access_path(adm_access), pool));
3265 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
3266 svn_wc__adm_get_db(adm_access),
3269 SVN_ERR(svn_wc_get_ignores2(patterns, wc_ctx, local_abspath, config, pool,
3272 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3276 svn_wc_status2(svn_wc_status2_t **status,
3278 svn_wc_adm_access_t *adm_access,
3281 const char *local_abspath;
3282 svn_wc_context_t *wc_ctx;
3283 svn_wc_status3_t *stat3;
3285 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
3286 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
3287 svn_wc__adm_get_db(adm_access),
3290 SVN_ERR(svn_wc_status3(&stat3, wc_ctx, local_abspath, pool, pool));
3291 SVN_ERR(svn_wc__status2_from_3(status, stat3, wc_ctx, local_abspath,
3294 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3298 /*** From update_editor.c ***/
3301 svn_wc_add_repos_file3(const char *dst_path,
3302 svn_wc_adm_access_t *adm_access,
3303 svn_stream_t *new_base_contents,
3304 svn_stream_t *new_contents,
3305 apr_hash_t *new_base_props,
3306 apr_hash_t *new_props,
3307 const char *copyfrom_url,
3308 svn_revnum_t copyfrom_rev,
3309 svn_cancel_func_t cancel_func,
3311 svn_wc_notify_func2_t notify_func,
3315 const char *local_abspath;
3316 svn_wc_context_t *wc_ctx;
3318 SVN_ERR(svn_dirent_get_absolute(&local_abspath, dst_path, pool));
3319 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
3320 svn_wc__adm_get_db(adm_access),
3323 SVN_ERR(svn_wc_add_repos_file4(wc_ctx,
3331 cancel_func, cancel_baton,
3334 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3338 svn_wc_add_repos_file2(const char *dst_path,
3339 svn_wc_adm_access_t *adm_access,
3340 const char *new_text_base_path,
3341 const char *new_text_path,
3342 apr_hash_t *new_base_props,
3343 apr_hash_t *new_props,
3344 const char *copyfrom_url,
3345 svn_revnum_t copyfrom_rev,
3348 svn_stream_t *new_base_contents;
3349 svn_stream_t *new_contents = NULL;
3351 SVN_ERR(svn_stream_open_readonly(&new_base_contents, new_text_base_path,
3356 /* NOTE: the specified path may *not* be under version control.
3357 It is most likely sitting in .svn/tmp/. Thus, we cannot use the
3358 typical WC functions to access "special", "keywords" or "EOL"
3359 information. We need to look at the properties given to us. */
3361 /* If the new file is special, then we can simply open the given
3362 contents since it is already in normal form. */
3363 if (svn_hash_gets(new_props, SVN_PROP_SPECIAL) != NULL)
3365 SVN_ERR(svn_stream_open_readonly(&new_contents, new_text_path,
3370 /* The new text contents need to be detrans'd into normal form. */
3371 svn_subst_eol_style_t eol_style;
3372 const char *eol_str;
3373 apr_hash_t *keywords = NULL;
3376 list = svn_hash_gets(new_props, SVN_PROP_KEYWORDS);
3379 /* Since we are detranslating, all of the keyword values
3381 SVN_ERR(svn_subst_build_keywords2(&keywords,
3385 if (apr_hash_count(keywords) == 0)
3389 svn_subst_eol_style_from_value(&eol_style, &eol_str,
3390 svn_hash_gets(new_props,
3391 SVN_PROP_EOL_STYLE));
3393 if (svn_subst_translation_required(eol_style, eol_str, keywords,
3396 SVN_ERR(svn_subst_stream_detranslated(&new_contents,
3406 SVN_ERR(svn_stream_open_readonly(&new_contents, new_text_path,
3412 SVN_ERR(svn_wc_add_repos_file3(dst_path, adm_access,
3413 new_base_contents, new_contents,
3414 new_base_props, new_props,
3415 copyfrom_url, copyfrom_rev,
3416 NULL, NULL, NULL, NULL,
3419 /* The API contract states that the text files will be removed upon
3420 successful completion. add_repos_file3() does not remove the files
3421 since it only has streams on them. Toss 'em now. */
3422 svn_error_clear(svn_io_remove_file(new_text_base_path, pool));
3424 svn_error_clear(svn_io_remove_file(new_text_path, pool));
3426 return SVN_NO_ERROR;
3431 svn_wc_add_repos_file(const char *dst_path,
3432 svn_wc_adm_access_t *adm_access,
3433 const char *new_text_path,
3434 apr_hash_t *new_props,
3435 const char *copyfrom_url,
3436 svn_revnum_t copyfrom_rev,
3439 return svn_wc_add_repos_file2(dst_path, adm_access,
3440 new_text_path, NULL,
3442 copyfrom_url, copyfrom_rev,
3447 svn_wc_get_actual_target(const char *path,
3448 const char **anchor,
3449 const char **target,
3452 svn_wc_context_t *wc_ctx;
3454 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
3455 SVN_ERR(svn_wc_get_actual_target2(anchor, target, wc_ctx, path, pool, pool));
3457 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3460 /* This function has no internal variant as its behavior on switched
3461 non-directories is not what you would expect. But this happens to
3462 be the legacy behavior of this function. */
3464 svn_wc_is_wc_root2(svn_boolean_t *wc_root,
3465 svn_wc_context_t *wc_ctx,
3466 const char *local_abspath,
3467 apr_pool_t *scratch_pool)
3469 svn_boolean_t is_root;
3470 svn_boolean_t is_switched;
3471 svn_node_kind_t kind;
3473 SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
3475 err = svn_wc__db_is_switched(&is_root, &is_switched, &kind,
3476 wc_ctx->db, local_abspath, scratch_pool);
3480 if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND &&
3481 err->apr_err != SVN_ERR_WC_NOT_WORKING_COPY)
3482 return svn_error_trace(err);
3484 return svn_error_create(SVN_ERR_ENTRY_NOT_FOUND, err, err->message);
3487 *wc_root = is_root || (kind == svn_node_dir && is_switched);
3489 return SVN_NO_ERROR;
3493 svn_wc_is_wc_root(svn_boolean_t *wc_root,
3495 svn_wc_adm_access_t *adm_access,
3498 svn_wc_context_t *wc_ctx;
3499 const char *local_abspath;
3502 /* Subversion <= 1.6 said that '.' or a drive root is a WC root. */
3503 if (svn_path_is_empty(path) || svn_dirent_is_root(path, strlen(path)))
3506 return SVN_NO_ERROR;
3509 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
3510 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
3511 svn_wc__adm_get_db(adm_access),
3514 err = svn_wc_is_wc_root2(wc_root, wc_ctx, local_abspath, pool);
3517 && (err->apr_err == SVN_ERR_WC_NOT_WORKING_COPY
3518 || err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND))
3520 /* Subversion <= 1.6 said that an unversioned path is a WC root. */
3521 svn_error_clear(err);
3527 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
3532 svn_wc_get_update_editor4(const svn_delta_editor_t **editor,
3534 svn_revnum_t *target_revision,
3535 svn_wc_context_t *wc_ctx,
3536 const char *anchor_abspath,
3537 const char *target_basename,
3538 svn_boolean_t use_commit_times,
3540 svn_boolean_t depth_is_sticky,
3541 svn_boolean_t allow_unver_obstructions,
3542 svn_boolean_t adds_as_modification,
3543 svn_boolean_t server_performs_filtering,
3544 svn_boolean_t clean_checkout,
3545 const char *diff3_cmd,
3546 const apr_array_header_t *preserved_exts,
3547 svn_wc_dirents_func_t fetch_dirents_func,
3548 void *fetch_dirents_baton,
3549 svn_wc_conflict_resolver_func2_t conflict_func,
3550 void *conflict_baton,
3551 svn_wc_external_update_t external_func,
3552 void *external_baton,
3553 svn_cancel_func_t cancel_func,
3555 svn_wc_notify_func2_t notify_func,
3557 apr_pool_t *result_pool,
3558 apr_pool_t *scratch_pool)
3560 return svn_error_trace(
3561 svn_wc__get_update_editor(editor, edit_baton,
3565 target_basename, NULL,
3567 depth, depth_is_sticky,
3568 allow_unver_obstructions,
3569 adds_as_modification,
3570 server_performs_filtering,
3574 fetch_dirents_func, fetch_dirents_baton,
3575 conflict_func, conflict_baton,
3576 external_func, external_baton,
3577 cancel_func, cancel_baton,
3578 notify_func, notify_baton,
3579 result_pool, scratch_pool));
3584 svn_wc_get_update_editor3(svn_revnum_t *target_revision,
3585 svn_wc_adm_access_t *anchor,
3587 svn_boolean_t use_commit_times,
3589 svn_boolean_t depth_is_sticky,
3590 svn_boolean_t allow_unver_obstructions,
3591 svn_wc_notify_func2_t notify_func,
3593 svn_cancel_func_t cancel_func,
3595 svn_wc_conflict_resolver_func_t conflict_func,
3596 void *conflict_baton,
3597 svn_wc_get_file_t fetch_func,
3599 const char *diff3_cmd,
3600 const apr_array_header_t *preserved_exts,
3601 const svn_delta_editor_t **editor,
3603 svn_wc_traversal_info_t *traversal_info,
3606 svn_wc_context_t *wc_ctx;
3607 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
3608 svn_wc_external_update_t external_func = NULL;
3609 struct traversal_info_update_baton *eb = NULL;
3610 struct conflict_func_1to2_baton *cfw = NULL;
3612 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
3616 eb = apr_palloc(pool, sizeof(*eb));
3618 eb->traversal = traversal_info;
3619 external_func = traversal_info_update;
3624 cfw = apr_pcalloc(pool, sizeof(*cfw));
3625 cfw->inner_func = conflict_func;
3626 cfw->inner_baton = conflict_baton;
3630 SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
3632 SVN_ERR(svn_wc_get_update_editor4(editor, edit_baton,
3635 svn_wc__adm_access_abspath(anchor),
3638 depth, depth_is_sticky,
3639 allow_unver_obstructions,
3640 TRUE /* adds_as_modification */,
3641 FALSE /* server_performs_filtering */,
3642 FALSE /* clean_checkout */,
3645 NULL, NULL, /* fetch_dirents_func, baton */
3646 conflict_func ? conflict_func_1to2_wrapper
3650 cancel_func, cancel_baton,
3651 notify_func, notify_baton,
3654 /* We can't destroy wc_ctx here, because the editor needs it while it's
3656 return SVN_NO_ERROR;
3660 svn_wc_get_update_editor2(svn_revnum_t *target_revision,
3661 svn_wc_adm_access_t *anchor,
3663 svn_boolean_t use_commit_times,
3664 svn_boolean_t recurse,
3665 svn_wc_notify_func2_t notify_func,
3667 svn_cancel_func_t cancel_func,
3669 const char *diff3_cmd,
3670 const svn_delta_editor_t **editor,
3672 svn_wc_traversal_info_t *traversal_info,
3675 return svn_wc_get_update_editor3(target_revision, anchor, target,
3677 SVN_DEPTH_INFINITY_OR_FILES(recurse), FALSE,
3678 FALSE, notify_func, notify_baton,
3679 cancel_func, cancel_baton, NULL, NULL,
3681 diff3_cmd, NULL, editor, edit_baton,
3682 traversal_info, pool);
3686 svn_wc_get_update_editor(svn_revnum_t *target_revision,
3687 svn_wc_adm_access_t *anchor,
3689 svn_boolean_t use_commit_times,
3690 svn_boolean_t recurse,
3691 svn_wc_notify_func_t notify_func,
3693 svn_cancel_func_t cancel_func,
3695 const char *diff3_cmd,
3696 const svn_delta_editor_t **editor,
3698 svn_wc_traversal_info_t *traversal_info,
3701 /* This baton must live beyond this function. Alloc on heap. */
3702 struct compat_notify_baton_t *nb = apr_palloc(pool, sizeof(*nb));
3704 nb->func = notify_func;
3705 nb->baton = notify_baton;
3707 return svn_wc_get_update_editor3(target_revision, anchor, target,
3709 SVN_DEPTH_INFINITY_OR_FILES(recurse), FALSE,
3710 FALSE, compat_call_notify_func, nb,
3711 cancel_func, cancel_baton, NULL, NULL,
3713 diff3_cmd, NULL, editor, edit_baton,
3714 traversal_info, pool);
3719 svn_wc_get_switch_editor4(const svn_delta_editor_t **editor,
3721 svn_revnum_t *target_revision,
3722 svn_wc_context_t *wc_ctx,
3723 const char *anchor_abspath,
3724 const char *target_basename,
3725 const char *switch_url,
3726 svn_boolean_t use_commit_times,
3728 svn_boolean_t depth_is_sticky,
3729 svn_boolean_t allow_unver_obstructions,
3730 svn_boolean_t server_performs_filtering,
3731 const char *diff3_cmd,
3732 const apr_array_header_t *preserved_exts,
3733 svn_wc_dirents_func_t fetch_dirents_func,
3734 void *fetch_dirents_baton,
3735 svn_wc_conflict_resolver_func2_t conflict_func,
3736 void *conflict_baton,
3737 svn_wc_external_update_t external_func,
3738 void *external_baton,
3739 svn_cancel_func_t cancel_func,
3741 svn_wc_notify_func2_t notify_func,
3743 apr_pool_t *result_pool,
3744 apr_pool_t *scratch_pool)
3746 return svn_error_trace(
3747 svn_wc__get_switch_editor(editor, edit_baton,
3750 anchor_abspath, target_basename,
3753 depth, depth_is_sticky,
3754 allow_unver_obstructions,
3755 server_performs_filtering,
3758 fetch_dirents_func, fetch_dirents_baton,
3759 conflict_func, conflict_baton,
3760 external_func, external_baton,
3761 cancel_func, cancel_baton,
3762 notify_func, notify_baton,
3763 result_pool, scratch_pool));
3768 svn_wc_get_switch_editor3(svn_revnum_t *target_revision,
3769 svn_wc_adm_access_t *anchor,
3771 const char *switch_url,
3772 svn_boolean_t use_commit_times,
3774 svn_boolean_t depth_is_sticky,
3775 svn_boolean_t allow_unver_obstructions,
3776 svn_wc_notify_func2_t notify_func,
3778 svn_cancel_func_t cancel_func,
3780 svn_wc_conflict_resolver_func_t conflict_func,
3781 void *conflict_baton,
3782 const char *diff3_cmd,
3783 const apr_array_header_t *preserved_exts,
3784 const svn_delta_editor_t **editor,
3786 svn_wc_traversal_info_t *traversal_info,
3789 svn_wc_context_t *wc_ctx;
3790 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
3791 svn_wc_external_update_t external_func = NULL;
3792 struct traversal_info_update_baton *eb = NULL;
3793 struct conflict_func_1to2_baton *cfw = NULL;
3795 SVN_ERR_ASSERT(switch_url && svn_uri_is_canonical(switch_url, pool));
3797 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
3801 eb = apr_palloc(pool, sizeof(*eb));
3803 eb->traversal = traversal_info;
3804 external_func = traversal_info_update;
3809 cfw = apr_pcalloc(pool, sizeof(*cfw));
3810 cfw->inner_func = conflict_func;
3811 cfw->inner_baton = conflict_baton;
3815 SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
3817 SVN_ERR(svn_wc_get_switch_editor4(editor, edit_baton,
3820 svn_wc__adm_access_abspath(anchor),
3823 depth, depth_is_sticky,
3824 allow_unver_obstructions,
3825 FALSE /* server_performs_filtering */,
3828 NULL, NULL, /* fetch_dirents_func, baton */
3829 conflict_func ? conflict_func_1to2_wrapper
3833 cancel_func, cancel_baton,
3834 notify_func, notify_baton,
3837 /* We can't destroy wc_ctx here, because the editor needs it while it's
3839 return SVN_NO_ERROR;
3843 svn_wc_get_switch_editor2(svn_revnum_t *target_revision,
3844 svn_wc_adm_access_t *anchor,
3846 const char *switch_url,
3847 svn_boolean_t use_commit_times,
3848 svn_boolean_t recurse,
3849 svn_wc_notify_func2_t notify_func,
3851 svn_cancel_func_t cancel_func,
3853 const char *diff3_cmd,
3854 const svn_delta_editor_t **editor,
3856 svn_wc_traversal_info_t *traversal_info,
3859 SVN_ERR_ASSERT(switch_url);
3861 return svn_wc_get_switch_editor3(target_revision, anchor, target,
3862 switch_url, use_commit_times,
3863 SVN_DEPTH_INFINITY_OR_FILES(recurse), FALSE,
3864 FALSE, notify_func, notify_baton,
3865 cancel_func, cancel_baton,
3866 NULL, NULL, diff3_cmd,
3867 NULL, editor, edit_baton, traversal_info,
3872 svn_wc_get_switch_editor(svn_revnum_t *target_revision,
3873 svn_wc_adm_access_t *anchor,
3875 const char *switch_url,
3876 svn_boolean_t use_commit_times,
3877 svn_boolean_t recurse,
3878 svn_wc_notify_func_t notify_func,
3880 svn_cancel_func_t cancel_func,
3882 const char *diff3_cmd,
3883 const svn_delta_editor_t **editor,
3885 svn_wc_traversal_info_t *traversal_info,
3888 /* This baton must live beyond this function. Alloc on heap. */
3889 struct compat_notify_baton_t *nb = apr_palloc(pool, sizeof(*nb));
3891 nb->func = notify_func;
3892 nb->baton = notify_baton;
3894 return svn_wc_get_switch_editor3(target_revision, anchor, target,
3895 switch_url, use_commit_times,
3896 SVN_DEPTH_INFINITY_OR_FILES(recurse), FALSE,
3897 FALSE, compat_call_notify_func, nb,
3898 cancel_func, cancel_baton,
3899 NULL, NULL, diff3_cmd,
3900 NULL, editor, edit_baton, traversal_info,
3906 svn_wc_external_item_create(const svn_wc_external_item2_t **item,
3909 *item = apr_pcalloc(pool, sizeof(svn_wc_external_item2_t));
3910 return SVN_NO_ERROR;
3913 svn_wc_external_item_t *
3914 svn_wc_external_item_dup(const svn_wc_external_item_t *item,
3917 svn_wc_external_item_t *new_item = apr_palloc(pool, sizeof(*new_item));
3921 if (new_item->target_dir)
3922 new_item->target_dir = apr_pstrdup(pool, new_item->target_dir);
3925 new_item->url = apr_pstrdup(pool, new_item->url);
3931 svn_wc_traversal_info_t *
3932 svn_wc_init_traversal_info(apr_pool_t *pool)
3934 svn_wc_traversal_info_t *ti = apr_palloc(pool, sizeof(*ti));
3937 ti->externals_old = apr_hash_make(pool);
3938 ti->externals_new = apr_hash_make(pool);
3939 ti->depths = apr_hash_make(pool);
3946 svn_wc_edited_externals(apr_hash_t **externals_old,
3947 apr_hash_t **externals_new,
3948 svn_wc_traversal_info_t *traversal_info)
3950 *externals_old = traversal_info->externals_old;
3951 *externals_new = traversal_info->externals_new;
3956 svn_wc_traversed_depths(apr_hash_t **depths,
3957 svn_wc_traversal_info_t *traversal_info)
3959 *depths = traversal_info->depths;
3963 /*** From lock.c ***/
3965 /* To preserve API compatibility with Subversion 1.0.0 */
3967 svn_wc_adm_open(svn_wc_adm_access_t **adm_access,
3968 svn_wc_adm_access_t *associated,
3970 svn_boolean_t write_lock,
3971 svn_boolean_t tree_lock,
3974 return svn_wc_adm_open3(adm_access, associated, path, write_lock,
3975 (tree_lock ? -1 : 0), NULL, NULL, pool);
3979 svn_wc_adm_open2(svn_wc_adm_access_t **adm_access,
3980 svn_wc_adm_access_t *associated,
3982 svn_boolean_t write_lock,
3986 return svn_wc_adm_open3(adm_access, associated, path, write_lock,
3987 levels_to_lock, NULL, NULL, pool);
3991 svn_wc_adm_probe_open(svn_wc_adm_access_t **adm_access,
3992 svn_wc_adm_access_t *associated,
3994 svn_boolean_t write_lock,
3995 svn_boolean_t tree_lock,
3998 return svn_wc_adm_probe_open3(adm_access, associated, path,
3999 write_lock, (tree_lock ? -1 : 0),
4005 svn_wc_adm_probe_open2(svn_wc_adm_access_t **adm_access,
4006 svn_wc_adm_access_t *associated,
4008 svn_boolean_t write_lock,
4012 return svn_wc_adm_probe_open3(adm_access, associated, path, write_lock,
4013 levels_to_lock, NULL, NULL, pool);
4017 svn_wc_adm_probe_try2(svn_wc_adm_access_t **adm_access,
4018 svn_wc_adm_access_t *associated,
4020 svn_boolean_t write_lock,
4024 return svn_wc_adm_probe_try3(adm_access, associated, path, write_lock,
4025 levels_to_lock, NULL, NULL, pool);
4029 svn_wc_adm_probe_try(svn_wc_adm_access_t **adm_access,
4030 svn_wc_adm_access_t *associated,
4032 svn_boolean_t write_lock,
4033 svn_boolean_t tree_lock,
4036 return svn_wc_adm_probe_try3(adm_access, associated, path, write_lock,
4037 (tree_lock ? -1 : 0), NULL, NULL, pool);
4041 svn_wc_adm_close(svn_wc_adm_access_t *adm_access)
4043 /* This is the only pool we have access to. */
4044 apr_pool_t *scratch_pool = svn_wc_adm_access_pool(adm_access);
4046 return svn_wc_adm_close2(adm_access, scratch_pool);
4050 svn_wc_locked(svn_boolean_t *locked,
4054 svn_wc_context_t *wc_ctx;
4055 const char *local_abspath;
4057 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4058 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
4060 SVN_ERR(svn_wc_locked2(NULL, locked, wc_ctx, local_abspath, pool));
4062 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4066 svn_wc_check_wc(const char *path,
4070 svn_wc_context_t *wc_ctx;
4071 const char *local_abspath;
4073 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4074 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
4076 SVN_ERR(svn_wc_check_wc2(wc_format, wc_ctx, local_abspath, pool));
4078 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4082 /*** From translate.c ***/
4085 svn_wc_translated_file(const char **xlated_p,
4087 svn_wc_adm_access_t *adm_access,
4088 svn_boolean_t force_repair,
4091 return svn_wc_translated_file2(xlated_p, vfile, vfile, adm_access,
4092 SVN_WC_TRANSLATE_TO_NF
4094 SVN_WC_TRANSLATE_FORCE_EOL_REPAIR : 0),
4099 svn_wc_translated_stream(svn_stream_t **stream,
4101 const char *versioned_file,
4102 svn_wc_adm_access_t *adm_access,
4106 const char *local_abspath;
4107 const char *versioned_abspath;
4109 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4110 SVN_ERR(svn_dirent_get_absolute(&versioned_abspath, versioned_file, pool));
4112 return svn_error_trace(
4113 svn_wc__internal_translated_stream(stream, svn_wc__adm_get_db(adm_access),
4114 local_abspath, versioned_abspath, flags,
4119 svn_wc_translated_file2(const char **xlated_path,
4121 const char *versioned_file,
4122 svn_wc_adm_access_t *adm_access,
4126 const char *versioned_abspath;
4128 const char *tmp_root;
4129 const char *src_abspath;
4131 SVN_ERR(svn_dirent_get_absolute(&versioned_abspath, versioned_file, pool));
4132 SVN_ERR(svn_dirent_get_absolute(&src_abspath, src, pool));
4134 SVN_ERR(svn_wc__internal_translated_file(xlated_path, src_abspath,
4135 svn_wc__adm_get_db(adm_access),
4137 flags, NULL, NULL, pool, pool));
4139 if (strcmp(*xlated_path, src_abspath) == 0)
4141 else if (! svn_dirent_is_absolute(versioned_file))
4143 SVN_ERR(svn_io_temp_dir(&tmp_root, pool));
4144 if (! svn_dirent_is_child(tmp_root, *xlated_path, pool))
4146 SVN_ERR(svn_dirent_get_absolute(&root, "", pool));
4148 if (svn_dirent_is_child(root, *xlated_path, pool))
4149 *xlated_path = svn_dirent_is_child(root, *xlated_path, pool);
4153 return SVN_NO_ERROR;
4156 /*** From relocate.c ***/
4158 svn_wc_relocate3(const char *path,
4159 svn_wc_adm_access_t *adm_access,
4162 svn_boolean_t recurse,
4163 svn_wc_relocation_validator3_t validator,
4164 void *validator_baton,
4167 const char *local_abspath;
4168 svn_wc_context_t *wc_ctx;
4171 SVN_ERR(svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
4172 _("Non-recursive relocation not supported")));
4174 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4175 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
4176 svn_wc__adm_get_db(adm_access),
4179 SVN_ERR(svn_wc_relocate4(wc_ctx, local_abspath, from, to,
4180 validator, validator_baton, pool));
4182 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4185 /* Compatibility baton and wrapper. */
4186 struct compat2_baton {
4187 svn_wc_relocation_validator2_t validator;
4191 /* Compatibility baton and wrapper. */
4192 struct compat_baton {
4193 svn_wc_relocation_validator_t validator;
4197 /* This implements svn_wc_relocate_validator3_t. */
4198 static svn_error_t *
4199 compat2_validator(void *baton,
4202 const char *root_url,
4205 struct compat2_baton *cb = baton;
4206 /* The old callback type doesn't set root_url. */
4207 return cb->validator(cb->baton, uuid,
4208 (root_url ? root_url : url), (root_url != NULL),
4212 /* This implements svn_wc_relocate_validator3_t. */
4213 static svn_error_t *
4214 compat_validator(void *baton,
4217 const char *root_url,
4220 struct compat_baton *cb = baton;
4221 /* The old callback type doesn't allow uuid to be NULL. */
4223 return cb->validator(cb->baton, uuid, url);
4224 return SVN_NO_ERROR;
4228 svn_wc_relocate2(const char *path,
4229 svn_wc_adm_access_t *adm_access,
4232 svn_boolean_t recurse,
4233 svn_wc_relocation_validator2_t validator,
4234 void *validator_baton,
4237 struct compat2_baton cb;
4239 cb.validator = validator;
4240 cb.baton = validator_baton;
4242 return svn_wc_relocate3(path, adm_access, from, to, recurse,
4243 compat2_validator, &cb, pool);
4247 svn_wc_relocate(const char *path,
4248 svn_wc_adm_access_t *adm_access,
4251 svn_boolean_t recurse,
4252 svn_wc_relocation_validator_t validator,
4253 void *validator_baton,
4256 struct compat_baton cb;
4258 cb.validator = validator;
4259 cb.baton = validator_baton;
4261 return svn_wc_relocate3(path, adm_access, from, to, recurse,
4262 compat_validator, &cb, pool);
4266 /*** From log.c / cleanup.c ***/
4269 svn_wc_cleanup3(svn_wc_context_t *wc_ctx,
4270 const char *local_abspath,
4271 svn_cancel_func_t cancel_func,
4273 apr_pool_t *scratch_pool)
4275 return svn_error_trace(
4276 svn_wc_cleanup4(wc_ctx,
4278 TRUE /* break_locks */,
4279 TRUE /* fix_recorded_timestamps */,
4280 TRUE /* clear_dav_cache */,
4281 TRUE /* clean_pristines */,
4282 cancel_func, cancel_baton,
4283 NULL, NULL /* notify */,
4288 svn_wc_cleanup2(const char *path,
4289 const char *diff3_cmd,
4290 svn_cancel_func_t cancel_func,
4294 svn_wc_context_t *wc_ctx;
4295 const char *local_abspath;
4297 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4298 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
4300 SVN_ERR(svn_wc_cleanup3(wc_ctx, local_abspath, cancel_func,
4301 cancel_baton, pool));
4303 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4307 svn_wc_cleanup(const char *path,
4308 svn_wc_adm_access_t *optional_adm_access,
4309 const char *diff3_cmd,
4310 svn_cancel_func_t cancel_func,
4314 return svn_wc_cleanup2(path, diff3_cmd, cancel_func, cancel_baton, pool);
4317 /*** From questions.c ***/
4320 svn_wc_has_binary_prop(svn_boolean_t *has_binary_prop,
4322 svn_wc_adm_access_t *adm_access,
4325 svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
4326 const char *local_abspath;
4327 const svn_string_t *value;
4329 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4331 SVN_ERR(svn_wc__internal_propget(&value, db, local_abspath,
4335 if (value && (svn_mime_type_is_binary(value->data)))
4336 *has_binary_prop = TRUE;
4338 *has_binary_prop = FALSE;
4340 return SVN_NO_ERROR;
4344 svn_wc_conflicted_p2(svn_boolean_t *text_conflicted_p,
4345 svn_boolean_t *prop_conflicted_p,
4346 svn_boolean_t *tree_conflicted_p,
4348 svn_wc_adm_access_t *adm_access,
4351 const char *local_abspath;
4352 svn_wc_context_t *wc_ctx;
4355 SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
4356 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */,
4357 svn_wc__adm_get_db(adm_access),
4360 err = svn_wc_conflicted_p3(text_conflicted_p, prop_conflicted_p,
4361 tree_conflicted_p, wc_ctx, local_abspath, pool);
4363 if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
4365 svn_error_clear(err);
4367 if (text_conflicted_p)
4368 *text_conflicted_p = FALSE;
4369 if (prop_conflicted_p)
4370 *prop_conflicted_p = FALSE;
4371 if (tree_conflicted_p)
4372 *tree_conflicted_p = FALSE;
4377 return SVN_NO_ERROR;
4381 svn_wc_conflicted_p(svn_boolean_t *text_conflicted_p,
4382 svn_boolean_t *prop_conflicted_p,
4383 const char *dir_path,
4384 const svn_wc_entry_t *entry,
4387 svn_node_kind_t kind;
4390 *text_conflicted_p = FALSE;
4391 *prop_conflicted_p = FALSE;
4393 if (entry->conflict_old)
4395 path = svn_dirent_join(dir_path, entry->conflict_old, pool);
4396 SVN_ERR(svn_io_check_path(path, &kind, pool));
4397 *text_conflicted_p = (kind == svn_node_file);
4400 if ((! *text_conflicted_p) && (entry->conflict_new))
4402 path = svn_dirent_join(dir_path, entry->conflict_new, pool);
4403 SVN_ERR(svn_io_check_path(path, &kind, pool));
4404 *text_conflicted_p = (kind == svn_node_file);
4407 if ((! *text_conflicted_p) && (entry->conflict_wrk))
4409 path = svn_dirent_join(dir_path, entry->conflict_wrk, pool);
4410 SVN_ERR(svn_io_check_path(path, &kind, pool));
4411 *text_conflicted_p = (kind == svn_node_file);
4414 if (entry->prejfile)
4416 path = svn_dirent_join(dir_path, entry->prejfile, pool);
4417 SVN_ERR(svn_io_check_path(path, &kind, pool));
4418 *prop_conflicted_p = (kind == svn_node_file);
4421 return SVN_NO_ERROR;
4425 svn_wc_text_modified_p(svn_boolean_t *modified_p,
4426 const char *filename,
4427 svn_boolean_t force_comparison,
4428 svn_wc_adm_access_t *adm_access,
4431 svn_wc_context_t *wc_ctx;
4432 svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
4433 const char *local_abspath;
4435 SVN_ERR(svn_dirent_get_absolute(&local_abspath, filename, pool));
4436 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
4438 SVN_ERR(svn_wc_text_modified_p2(modified_p, wc_ctx, local_abspath,
4439 force_comparison, pool));
4441 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4445 /*** From copy.c ***/
4447 svn_wc_copy2(const char *src,
4448 svn_wc_adm_access_t *dst_parent,
4449 const char *dst_basename,
4450 svn_cancel_func_t cancel_func,
4452 svn_wc_notify_func2_t notify_func,
4456 svn_wc_context_t *wc_ctx;
4457 svn_wc__db_t *wc_db = svn_wc__adm_get_db(dst_parent);
4458 const char *src_abspath;
4459 const char *dst_abspath;
4461 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, wc_db, pool));
4462 SVN_ERR(svn_dirent_get_absolute(&src_abspath, src, pool));
4464 dst_abspath = svn_dirent_join(svn_wc__adm_access_abspath(dst_parent),
4465 dst_basename, pool);
4467 SVN_ERR(svn_wc_copy3(wc_ctx,
4470 FALSE /* metadata_only */,
4471 cancel_func, cancel_baton,
4472 notify_func, notify_baton,
4475 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4479 svn_wc_copy(const char *src_path,
4480 svn_wc_adm_access_t *dst_parent,
4481 const char *dst_basename,
4482 svn_cancel_func_t cancel_func,
4484 svn_wc_notify_func_t notify_func,
4488 struct compat_notify_baton_t nb;
4490 nb.func = notify_func;
4491 nb.baton = notify_baton;
4493 return svn_wc_copy2(src_path, dst_parent, dst_basename, cancel_func,
4494 cancel_baton, compat_call_notify_func,
4499 /*** From merge.c ***/
4502 svn_wc_merge4(enum svn_wc_merge_outcome_t *merge_outcome,
4503 svn_wc_context_t *wc_ctx,
4504 const char *left_abspath,
4505 const char *right_abspath,
4506 const char *target_abspath,
4507 const char *left_label,
4508 const char *right_label,
4509 const char *target_label,
4510 const svn_wc_conflict_version_t *left_version,
4511 const svn_wc_conflict_version_t *right_version,
4512 svn_boolean_t dry_run,
4513 const char *diff3_cmd,
4514 const apr_array_header_t *merge_options,
4515 const apr_array_header_t *prop_diff,
4516 svn_wc_conflict_resolver_func2_t conflict_func,
4517 void *conflict_baton,
4518 svn_cancel_func_t cancel_func,
4520 apr_pool_t *scratch_pool)
4522 return svn_error_trace(
4523 svn_wc_merge5(merge_outcome,
4524 NULL /* merge_props_outcome */,
4537 NULL /* original_props */,
4539 conflict_func, conflict_baton,
4540 cancel_func, cancel_baton,
4545 svn_wc_merge3(enum svn_wc_merge_outcome_t *merge_outcome,
4548 const char *merge_target,
4549 svn_wc_adm_access_t *adm_access,
4550 const char *left_label,
4551 const char *right_label,
4552 const char *target_label,
4553 svn_boolean_t dry_run,
4554 const char *diff3_cmd,
4555 const apr_array_header_t *merge_options,
4556 const apr_array_header_t *prop_diff,
4557 svn_wc_conflict_resolver_func_t conflict_func,
4558 void *conflict_baton,
4561 svn_wc_context_t *wc_ctx;
4562 svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
4563 const char *left_abspath, *right_abspath, *target_abspath;
4564 struct conflict_func_1to2_baton cfw;
4566 SVN_ERR(svn_dirent_get_absolute(&left_abspath, left, pool));
4567 SVN_ERR(svn_dirent_get_absolute(&right_abspath, right, pool));
4568 SVN_ERR(svn_dirent_get_absolute(&target_abspath, merge_target, pool));
4570 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL /* config */, db, pool));
4572 cfw.inner_func = conflict_func;
4573 cfw.inner_baton = conflict_baton;
4576 SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, pool));
4578 SVN_ERR(svn_wc_merge4(merge_outcome,
4592 conflict_func ? conflict_func_1to2_wrapper : NULL,
4597 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4601 svn_wc_merge2(enum svn_wc_merge_outcome_t *merge_outcome,
4604 const char *merge_target,
4605 svn_wc_adm_access_t *adm_access,
4606 const char *left_label,
4607 const char *right_label,
4608 const char *target_label,
4609 svn_boolean_t dry_run,
4610 const char *diff3_cmd,
4611 const apr_array_header_t *merge_options,
4614 return svn_wc_merge3(merge_outcome,
4615 left, right, merge_target, adm_access,
4616 left_label, right_label, target_label,
4617 dry_run, diff3_cmd, merge_options, NULL,
4622 svn_wc_merge(const char *left,
4624 const char *merge_target,
4625 svn_wc_adm_access_t *adm_access,
4626 const char *left_label,
4627 const char *right_label,
4628 const char *target_label,
4629 svn_boolean_t dry_run,
4630 enum svn_wc_merge_outcome_t *merge_outcome,
4631 const char *diff3_cmd,
4634 return svn_wc_merge3(merge_outcome,
4635 left, right, merge_target, adm_access,
4636 left_label, right_label, target_label,
4637 dry_run, diff3_cmd, NULL, NULL, NULL,
4642 /*** From util.c ***/
4644 svn_wc_conflict_version_t *
4645 svn_wc_conflict_version_create(const char *repos_url,
4646 const char *path_in_repos,
4647 svn_revnum_t peg_rev,
4648 svn_node_kind_t node_kind,
4651 return svn_wc_conflict_version_create2(repos_url, NULL, path_in_repos,
4652 peg_rev, node_kind, pool);
4655 svn_wc_conflict_description_t *
4656 svn_wc_conflict_description_create_text(const char *path,
4657 svn_wc_adm_access_t *adm_access,
4660 svn_wc_conflict_description_t *conflict;
4662 conflict = apr_pcalloc(pool, sizeof(*conflict));
4663 conflict->path = path;
4664 conflict->node_kind = svn_node_file;
4665 conflict->kind = svn_wc_conflict_kind_text;
4666 conflict->access = adm_access;
4667 conflict->action = svn_wc_conflict_action_edit;
4668 conflict->reason = svn_wc_conflict_reason_edited;
4672 svn_wc_conflict_description_t *
4673 svn_wc_conflict_description_create_prop(const char *path,
4674 svn_wc_adm_access_t *adm_access,
4675 svn_node_kind_t node_kind,
4676 const char *property_name,
4679 svn_wc_conflict_description_t *conflict;
4681 conflict = apr_pcalloc(pool, sizeof(*conflict));
4682 conflict->path = path;
4683 conflict->node_kind = node_kind;
4684 conflict->kind = svn_wc_conflict_kind_property;
4685 conflict->access = adm_access;
4686 conflict->property_name = property_name;
4690 svn_wc_conflict_description_t *
4691 svn_wc_conflict_description_create_tree(
4693 svn_wc_adm_access_t *adm_access,
4694 svn_node_kind_t node_kind,
4695 svn_wc_operation_t operation,
4696 svn_wc_conflict_version_t *src_left_version,
4697 svn_wc_conflict_version_t *src_right_version,
4700 svn_wc_conflict_description_t *conflict;
4702 conflict = apr_pcalloc(pool, sizeof(*conflict));
4703 conflict->path = path;
4704 conflict->node_kind = node_kind;
4705 conflict->kind = svn_wc_conflict_kind_tree;
4706 conflict->access = adm_access;
4707 conflict->operation = operation;
4708 conflict->src_left_version = src_left_version;
4709 conflict->src_right_version = src_right_version;
4714 /*** From revision_status.c ***/
4717 svn_wc_revision_status(svn_wc_revision_status_t **result_p,
4718 const char *wc_path,
4719 const char *trail_url,
4720 svn_boolean_t committed,
4721 svn_cancel_func_t cancel_func,
4725 svn_wc_context_t *wc_ctx;
4726 const char *local_abspath;
4728 SVN_ERR(svn_dirent_get_absolute(&local_abspath, wc_path, pool));
4729 SVN_ERR(svn_wc_context_create(&wc_ctx, NULL /* config */, pool, pool));
4731 SVN_ERR(svn_wc_revision_status2(result_p, wc_ctx, local_abspath, trail_url,
4732 committed, cancel_func, cancel_baton, pool,
4735 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4738 /*** From crop.c ***/
4740 svn_wc_crop_tree(svn_wc_adm_access_t *anchor,
4743 svn_wc_notify_func2_t notify_func,
4745 svn_cancel_func_t cancel_func,
4749 svn_wc_context_t *wc_ctx;
4750 svn_wc__db_t *db = svn_wc__adm_get_db(anchor);
4751 const char *local_abspath;
4753 local_abspath = svn_dirent_join(svn_wc__adm_access_abspath(anchor),
4756 SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL, db, pool));
4758 if (depth == svn_depth_exclude)
4760 SVN_ERR(svn_wc_exclude(wc_ctx,
4762 cancel_func, cancel_baton,
4763 notify_func, notify_baton,
4768 SVN_ERR(svn_wc_crop_tree2(wc_ctx,
4771 cancel_func, cancel_baton,
4772 notify_func, notify_baton,
4776 return svn_error_trace(svn_wc_context_destroy(wc_ctx));
4780 svn_wc_move(svn_wc_context_t *wc_ctx,
4781 const char *src_abspath,
4782 const char *dst_abspath,
4783 svn_boolean_t metadata_only,
4784 svn_cancel_func_t cancel_func,
4786 svn_wc_notify_func2_t notify_func,
4788 apr_pool_t *scratch_pool)
4790 return svn_error_trace(svn_wc__move2(wc_ctx, src_abspath, dst_abspath,
4792 TRUE, /* allow_mixed_revisions */
4793 cancel_func, cancel_baton,
4794 notify_func, notify_baton,
4799 svn_wc_read_kind(svn_node_kind_t *kind,
4800 svn_wc_context_t *wc_ctx,
4801 const char *abspath,
4802 svn_boolean_t show_hidden,
4803 apr_pool_t *scratch_pool)
4805 return svn_error_trace(
4806 svn_wc_read_kind2(kind,
4808 TRUE /* show_deleted */,
4813 svn_wc_conflict_description2_t *
4814 svn_wc__conflict_description2_dup(const svn_wc_conflict_description2_t *conflict,
4817 return svn_wc_conflict_description2_dup(conflict, pool);