55
57
typedef struct db_node_t {
57
59
const char *local_relpath;
59
61
apr_int64_t repos_id;
60
62
const char *repos_relpath;
61
63
const char *parent_relpath;
62
64
svn_wc__db_status_t presence;
63
65
svn_revnum_t revision;
64
svn_node_kind_t kind; /* ### should switch to svn_wc__db_kind_t */
65
67
svn_checksum_t *checksum;
66
svn_filesize_t translated_size;
68
svn_filesize_t recorded_size;
67
69
svn_revnum_t changed_rev;
68
70
apr_time_t changed_date;
69
71
const char *changed_author;
71
apr_time_t last_mod_time;
73
apr_time_t recorded_time;
72
74
apr_hash_t *properties;
73
75
svn_boolean_t file_external;
76
apr_array_header_t *inherited_props;
76
79
typedef struct db_actual_node_t {
205
208
static svn_error_t *
206
209
get_info_for_deleted(svn_wc_entry_t *entry,
207
svn_wc__db_kind_t *kind,
210
svn_node_kind_t *kind,
208
211
const char **repos_relpath,
209
212
const svn_checksum_t **checksum,
213
svn_wc__db_lock_t **lock,
210
214
svn_wc__db_t *db,
211
215
const char *entry_abspath,
212
216
const svn_wc_entry_t *parent_entry,
304
299
svn_wc__db_status_t status;
305
300
SVN_ERR(svn_wc__db_base_get_info(&status, NULL, &entry->revision,
306
301
NULL, NULL, NULL, NULL, NULL, NULL,
307
NULL, NULL, NULL, NULL, NULL, NULL,
302
NULL, NULL, NULL, lock, NULL, NULL,
308
304
db, entry_abspath,
309
305
result_pool, scratch_pool));
461
457
child_abspath = svn_dirent_join(dir_abspath, child_name,
464
SVN_ERR(svn_wc__db_read_conflicts(&child_conflicts,
466
scratch_pool, scratch_pool));
460
SVN_ERR(svn_wc__read_conflicts(&child_conflicts,
462
FALSE /* create tempfiles */,
463
scratch_pool, scratch_pool));
468
465
for (j = 0; j < child_conflicts->nelts; j++)
637
633
/* ### scan_addition may need to be updated to avoid returning
638
634
### status_copied in this case. */
640
else if (work_status == svn_wc__db_status_copied)
636
/* For backwards-compatiblity purposes we treat moves just like
638
else if (work_status == svn_wc__db_status_copied ||
639
work_status == svn_wc__db_status_moved_here)
642
641
entry->copied = TRUE;
662
661
svn_boolean_t is_copied_child;
663
662
svn_boolean_t is_mixed_rev = FALSE;
665
SVN_ERR_ASSERT(work_status == svn_wc__db_status_copied);
664
SVN_ERR_ASSERT(work_status == svn_wc__db_status_copied ||
665
work_status == svn_wc__db_status_moved_here);
667
667
/* If this node inherits copyfrom information from an
668
668
ancestor node, then it must be a copied child. */
836
836
if (entry->depth == svn_depth_unknown)
837
837
entry->depth = svn_depth_infinity;
839
if (kind == svn_wc__db_kind_dir)
839
if (kind == svn_node_dir)
840
840
entry->kind = svn_node_dir;
841
else if (kind == svn_wc__db_kind_file)
841
else if (kind == svn_node_file)
842
842
entry->kind = svn_node_file;
843
else if (kind == svn_wc__db_kind_symlink)
843
else if (kind == svn_node_symlink)
844
844
entry->kind = svn_node_file; /* ### no symlink kind */
846
846
entry->kind = svn_node_unknown;
881
const apr_array_header_t *conflicts;
883
SVN_ERR(svn_wc__db_read_conflicts(&conflicts, db, entry_abspath,
884
scratch_pool, scratch_pool));
886
for (j = 0; j < conflicts->nelts; j++)
888
const svn_wc_conflict_description2_t *cd;
889
cd = APR_ARRAY_IDX(conflicts, j,
890
const svn_wc_conflict_description2_t *);
894
case svn_wc_conflict_kind_text:
895
if (cd->base_abspath)
896
entry->conflict_old = svn_dirent_basename(cd->base_abspath,
898
if (cd->their_abspath)
899
entry->conflict_new = svn_dirent_basename(cd->their_abspath,
902
entry->conflict_wrk = svn_dirent_basename(cd->my_abspath,
905
case svn_wc_conflict_kind_property:
906
entry->prejfile = svn_dirent_basename(cd->their_abspath,
909
case svn_wc_conflict_kind_tree:
881
svn_skel_t *conflict;
882
svn_boolean_t text_conflicted;
883
svn_boolean_t prop_conflicted;
884
SVN_ERR(svn_wc__db_read_conflict(&conflict, db, entry_abspath,
885
scratch_pool, scratch_pool));
887
SVN_ERR(svn_wc__conflict_read_info(NULL, NULL, &text_conflicted,
888
&prop_conflicted, NULL,
889
db, dir_abspath, conflict,
890
scratch_pool, scratch_pool));
894
const char *my_abspath;
895
const char *their_old_abspath;
896
const char *their_abspath;
897
SVN_ERR(svn_wc__conflict_read_text_conflict(&my_abspath,
901
conflict, scratch_pool,
905
entry->conflict_wrk = svn_dirent_basename(my_abspath, result_pool);
907
if (their_old_abspath)
908
entry->conflict_old = svn_dirent_basename(their_old_abspath,
912
entry->conflict_new = svn_dirent_basename(their_abspath,
918
const char *prej_abspath;
920
SVN_ERR(svn_wc__conflict_read_prop_conflict(&prej_abspath, NULL,
923
conflict, scratch_pool,
927
entry->prejfile = svn_dirent_basename(prej_abspath, result_pool);
923
939
/* Let's check for a file external. ugh. */
924
940
if (status == svn_wc__db_status_normal
925
&& kind == svn_wc__db_kind_file)
941
&& kind == svn_node_file)
926
942
SVN_ERR(check_file_external(entry, db, entry_abspath, dir_abspath,
927
943
result_pool, scratch_pool));
957
973
NULL /* parent_entry */,
958
974
result_pool, iterpool));
959
apr_hash_set(entries, "", APR_HASH_KEY_STRING, parent_entry);
975
svn_hash_sets(entries, "", parent_entry);
961
977
/* Use result_pool so that the child names (used by reference, rather
962
978
than copied) appear in result_pool. */
973
989
SVN_ERR(read_one_entry(&entry,
974
990
db, wc_id, local_abspath, name, parent_entry,
975
991
result_pool, iterpool));
976
apr_hash_set(entries, entry->name, APR_HASH_KEY_STRING, entry);
992
svn_hash_sets(entries, entry->name, entry);
979
995
svn_pool_destroy(iterpool);
1379
svn_wc_entries_read(apr_hash_t **entries,
1380
svn_wc_adm_access_t *adm_access,
1381
svn_boolean_t show_hidden,
1395
svn_wc__entries_read_internal(apr_hash_t **entries,
1396
svn_wc_adm_access_t *adm_access,
1397
svn_boolean_t show_hidden,
1384
1400
apr_hash_t *new_entries;
1412
1428
*entries = new_entries;
1414
1430
SVN_ERR(prune_deleted(entries, new_entries,
1415
svn_wc_adm_access_pool(adm_access),
1431
svn_wc__adm_access_pool_internal(adm_access),
1418
1434
return SVN_NO_ERROR;
1438
svn_wc_entries_read(apr_hash_t **entries,
1439
svn_wc_adm_access_t *adm_access,
1440
svn_boolean_t show_hidden,
1443
return svn_error_trace(svn_wc__entries_read_internal(entries, adm_access,
1444
show_hidden, pool));
1422
1447
/* No transaction required: called from write_entry which is itself
1423
1448
transaction-wrapped. */
1431
1456
SVN_ERR_ASSERT(node->op_depth > 0 || node->repos_relpath);
1433
1458
SVN_ERR(svn_sqlite__get_statement(&stmt, sdb, STMT_INSERT_NODE));
1434
SVN_ERR(svn_sqlite__bindf(stmt, "isisnnnnsnrisnnni",
1459
SVN_ERR(svn_sqlite__bindf(stmt, "isdsnnnnsnrisnnni",
1436
1461
node->local_relpath,
1437
1462
node->op_depth,
1449
1474
node->repos_id));
1450
1475
SVN_ERR(svn_sqlite__bind_text(stmt, 6,
1451
1476
node->repos_relpath));
1452
SVN_ERR(svn_sqlite__bind_int64(stmt, 7, node->revision));
1477
SVN_ERR(svn_sqlite__bind_revnum(stmt, 7, node->revision));
1455
1480
if (node->presence == svn_wc__db_status_normal)
1463
1488
else if (node->presence == svn_wc__db_status_excluded)
1464
1489
SVN_ERR(svn_sqlite__bind_text(stmt, 8, "excluded"));
1465
1490
else if (node->presence == svn_wc__db_status_server_excluded)
1466
SVN_ERR(svn_sqlite__bind_text(stmt, 8, "absent"));
1491
SVN_ERR(svn_sqlite__bind_text(stmt, 8, "server-excluded"));
1468
1493
if (node->kind == svn_node_none)
1469
1494
SVN_ERR(svn_sqlite__bind_text(stmt, 10, "unknown"));
1491
1516
SVN_ERR(svn_sqlite__bind_properties(stmt, 15, node->properties,
1492
1517
scratch_pool));
1494
if (node->translated_size != SVN_INVALID_FILESIZE)
1495
SVN_ERR(svn_sqlite__bind_int64(stmt, 16, node->translated_size));
1519
if (node->recorded_size != SVN_INVALID_FILESIZE)
1520
SVN_ERR(svn_sqlite__bind_int64(stmt, 16, node->recorded_size));
1497
1522
if (node->file_external)
1498
1523
SVN_ERR(svn_sqlite__bind_int(stmt, 20, 1));
1525
if (node->inherited_props)
1526
SVN_ERR(svn_sqlite__bind_iprops(stmt, 23, node->inherited_props,
1500
1529
SVN_ERR(svn_sqlite__insert(NULL, stmt));
1502
1531
return SVN_NO_ERROR;
1507
1536
static svn_error_t *
1508
1537
insert_actual_node(svn_sqlite__db_t *sdb,
1539
const char *wri_abspath,
1509
1540
const db_actual_node_t *actual_node,
1510
1541
apr_pool_t *scratch_pool)
1512
1543
svn_sqlite__stmt_t *stmt;
1544
svn_skel_t *conflict_data = NULL;
1514
1546
SVN_ERR(svn_sqlite__get_statement(&stmt, sdb, STMT_INSERT_ACTUAL_NODE));
1521
1553
SVN_ERR(svn_sqlite__bind_properties(stmt, 4, actual_node->properties,
1522
1554
scratch_pool));
1524
if (actual_node->conflict_old)
1526
SVN_ERR(svn_sqlite__bind_text(stmt, 5, actual_node->conflict_old));
1527
SVN_ERR(svn_sqlite__bind_text(stmt, 6, actual_node->conflict_new));
1528
SVN_ERR(svn_sqlite__bind_text(stmt, 7, actual_node->conflict_working));
1531
if (actual_node->prop_reject)
1532
SVN_ERR(svn_sqlite__bind_text(stmt, 8, actual_node->prop_reject));
1534
1556
if (actual_node->changelist)
1535
SVN_ERR(svn_sqlite__bind_text(stmt, 9, actual_node->changelist));
1537
if (actual_node->tree_conflict_data)
1538
SVN_ERR(svn_sqlite__bind_text(stmt, 10, actual_node->tree_conflict_data));
1557
SVN_ERR(svn_sqlite__bind_text(stmt, 5, actual_node->changelist));
1559
SVN_ERR(svn_wc__upgrade_conflict_skel_from_raw(
1562
actual_node->local_relpath,
1563
actual_node->conflict_old,
1564
actual_node->conflict_working,
1565
actual_node->conflict_new,
1566
actual_node->prop_reject,
1567
actual_node->tree_conflict_data,
1568
actual_node->tree_conflict_data
1569
? strlen(actual_node->tree_conflict_data)
1571
scratch_pool, scratch_pool));
1575
svn_stringbuf_t *data = svn_skel__unparse(conflict_data, scratch_pool);
1577
SVN_ERR(svn_sqlite__bind_blob(stmt, 6, data->data, data->len));
1540
1580
/* Execute and reset the insert clause. */
1541
1581
return svn_error_trace(svn_sqlite__insert(NULL, stmt));
1584
static svn_boolean_t
1585
is_switched(db_node_t *parent,
1587
apr_pool_t *scratch_pool)
1589
if (parent && child)
1591
if (parent->repos_id != child->repos_id)
1594
if (parent->repos_relpath && child->repos_relpath)
1596
const char *unswitched
1597
= svn_relpath_join(parent->repos_relpath,
1598
svn_relpath_basename(child->local_relpath,
1601
if (strcmp(unswitched, child->repos_relpath))
1544
1609
struct write_baton {
1545
1610
db_node_t *base;
1546
1611
db_node_t *work;
1548
1613
apr_hash_t *tree_conflicts;
1616
#define WRITE_ENTRY_ASSERT(expr) \
1618
return svn_error_createf(SVN_ERR_ASSERTION_FAIL, NULL, \
1619
_("Unable to upgrade '%s' at line %d"), \
1620
svn_dirent_local_style( \
1621
svn_dirent_join(root_abspath, \
1624
scratch_pool), __LINE__)
1552
1626
/* Write the information for ENTRY to WC_DB. The WC_ID, REPOS_ID and
1553
1627
REPOS_ROOT will all be used for writing ENTRY.
1663
1737
replace+copied replace+copied [base|work]+work [base|work]+work
1666
SVN_ERR_ASSERT(parent_node || entry->schedule == svn_wc_schedule_normal);
1667
SVN_ERR_ASSERT(!parent_node || parent_node->base
1668
|| parent_node->below_work || parent_node->work);
1740
WRITE_ENTRY_ASSERT(parent_node || entry->schedule == svn_wc_schedule_normal);
1742
WRITE_ENTRY_ASSERT(!parent_node || parent_node->base
1743
|| parent_node->below_work || parent_node->work);
1670
1745
switch (entry->schedule)
1729
1804
if (entry->copyfrom_url)
1731
const char *relpath;
1733
1806
working_node->repos_id = repos_id;
1734
relpath = svn_uri__is_child(this_dir->repos,
1735
entry->copyfrom_url,
1737
if (relpath == NULL)
1738
working_node->repos_relpath = "";
1740
working_node->repos_relpath = relpath;
1807
working_node->repos_relpath = svn_uri_skip_ancestor(
1808
this_dir->repos, entry->copyfrom_url,
1741
1810
working_node->revision = entry->copyfrom_rev;
1742
1811
working_node->op_depth
1743
1812
= svn_wc__db_op_depth_for_upgrade(local_relpath);
1752
1821
working_node->revision = parent_node->work->revision;
1753
1822
working_node->op_depth = parent_node->work->op_depth;
1824
else if (parent_node->below_work
1825
&& parent_node->below_work->repos_relpath)
1827
working_node->repos_id = repos_id;
1828
working_node->repos_relpath
1829
= svn_relpath_join(parent_node->below_work->repos_relpath,
1830
svn_relpath_basename(local_relpath, NULL),
1832
working_node->revision = parent_node->below_work->revision;
1833
working_node->op_depth = parent_node->below_work->op_depth;
1756
1836
return svn_error_createf(SVN_ERR_ENTRY_MISSING_URL, NULL,
1757
1837
_("No copyfrom URL for '%s'"),
1840
1920
/* Store in hash to be retrieved when writing the child
1842
1922
key = svn_dirent_skip_ancestor(root_abspath, conflict->local_abspath);
1843
apr_hash_set(tree_conflicts, apr_pstrdup(result_pool, key),
1844
APR_HASH_KEY_STRING,
1845
svn_skel__unparse(new_skel, result_pool)->data);
1923
svn_hash_sets(tree_conflicts, apr_pstrdup(result_pool, key),
1924
svn_skel__unparse(new_skel, result_pool)->data);
1846
1925
skel = skel->next;
1852
1931
if (parent_node && parent_node->tree_conflicts)
1854
const char *tree_conflict_data = apr_hash_get(parent_node->tree_conflicts,
1856
APR_HASH_KEY_STRING);
1933
const char *tree_conflict_data =
1934
svn_hash_gets(parent_node->tree_conflicts, local_relpath);
1857
1935
if (tree_conflict_data)
1859
1937
actual_node = MAYBE_ALLOC(actual_node, scratch_pool);
1863
1941
/* Reset hash so that we don't write the row again when writing
1864
1942
actual-only nodes */
1865
apr_hash_set(parent_node->tree_conflicts, local_relpath,
1866
APR_HASH_KEY_STRING, NULL);
1943
svn_hash_sets(parent_node->tree_conflicts, local_relpath, NULL);
1869
1946
if (entry->file_external_path != NULL)
1880
1957
base_node->op_depth = 0;
1881
1958
base_node->parent_relpath = parent_relpath;
1882
1959
base_node->revision = entry->revision;
1883
base_node->last_mod_time = entry->text_time;
1884
base_node->translated_size = entry->working_size;
1960
base_node->recorded_time = entry->text_time;
1961
base_node->recorded_size = entry->working_size;
1886
1963
if (entry->depth != svn_depth_exclude)
1887
1964
base_node->depth = entry->depth;
1894
1971
if (entry->deleted)
1896
SVN_ERR_ASSERT(base_node->presence == svn_wc__db_status_not_present);
1973
WRITE_ENTRY_ASSERT(base_node->presence
1974
== svn_wc__db_status_not_present);
1897
1975
/* ### should be svn_node_unknown, but let's store what we have. */
1898
1976
base_node->kind = entry->kind;
1900
1978
else if (entry->absent)
1902
SVN_ERR_ASSERT(base_node->presence
1903
== svn_wc__db_status_server_excluded);
1980
WRITE_ENTRY_ASSERT(base_node->presence
1981
== svn_wc__db_status_server_excluded);
1904
1982
/* ### should be svn_node_unknown, but let's store what we have. */
1905
1983
base_node->kind = entry->kind;
1933
2011
else if (entry->incomplete)
1935
2013
/* ### nobody should have set the presence. */
1936
SVN_ERR_ASSERT(base_node->presence
1937
== svn_wc__db_status_normal);
2014
WRITE_ENTRY_ASSERT(base_node->presence
2015
== svn_wc__db_status_normal);
1938
2016
base_node->presence = svn_wc__db_status_incomplete;
1996
2074
if (entry->url != NULL)
1998
const char *relpath = svn_uri__is_child(this_dir->repos,
2001
base_node->repos_relpath = relpath ? relpath : "";
2076
base_node->repos_relpath = svn_uri_skip_ancestor(
2077
this_dir->repos, entry->url,
2005
const char *relpath = svn_uri__is_child(this_dir->repos,
2008
if (relpath == NULL)
2082
const char *relpath = svn_uri_skip_ancestor(this_dir->repos,
2085
if (relpath == NULL || *relpath == '\0')
2009
2086
base_node->repos_relpath = entry->name;
2011
2088
base_node->repos_relpath =
2026
2103
if (entry->file_external_path)
2027
2104
base_node->file_external = TRUE;
2106
/* Switched nodes get an empty iprops cache. */
2108
&& is_switched(parent_node->base, base_node, scratch_pool))
2109
base_node->inherited_props
2110
= apr_array_make(scratch_pool, 0, sizeof(svn_prop_inherited_item_t*));
2029
2112
SVN_ERR(insert_node(sdb, base_node, scratch_pool));
2031
2114
/* We have to insert the lock after the base node, because the node
2057
2140
below_working_node->presence = svn_wc__db_status_normal;
2058
2141
below_working_node->kind = entry->kind;
2059
2142
below_working_node->repos_id = work->repos_id;
2144
/* This is just guessing. If the node below would have been switched
2145
or if it was updated to a different version, the guess would
2146
fail. But we don't have better information pre wc-ng :( */
2060
2147
if (work->repos_relpath)
2061
2148
below_working_node->repos_relpath
2062
2149
= svn_relpath_join(work->repos_relpath, entry->name,
2079
2166
below_working_node->checksum =
2080
2167
text_base_info->revert_base.sha1_checksum;
2082
below_working_node->translated_size = 0;
2169
below_working_node->recorded_size = 0;
2083
2170
below_working_node->changed_rev = SVN_INVALID_REVNUM;
2084
2171
below_working_node->changed_date = 0;
2085
2172
below_working_node->changed_author = NULL;
2086
2173
below_working_node->depth = svn_depth_infinity;
2087
below_working_node->last_mod_time = 0;
2174
below_working_node->recorded_time = 0;
2088
2175
below_working_node->properties = NULL;
2178
&& entry->schedule == svn_wc_schedule_delete
2179
&& working_node->repos_relpath)
2181
/* We are lucky, our guesses above are not necessary. The known
2182
correct information is in working. But our op_depth design
2183
expects more information here */
2184
below_working_node->repos_relpath = working_node->repos_relpath;
2185
below_working_node->repos_id = working_node->repos_id;
2186
below_working_node->revision = working_node->revision;
2188
/* Nice for 'svn status' */
2189
below_working_node->changed_rev = entry->cmt_rev;
2190
below_working_node->changed_date = entry->cmt_date;
2191
below_working_node->changed_author = entry->cmt_author;
2193
/* And now remove it from WORKING, because in wc-ng code
2194
should read it from the lower layer */
2195
working_node->repos_relpath = NULL;
2196
working_node->repos_id = 0;
2197
working_node->revision = SVN_INVALID_REVNUM;
2089
2200
SVN_ERR(insert_node(sdb, below_working_node, scratch_pool));
2096
2207
working_node->local_relpath = local_relpath;
2097
2208
working_node->parent_relpath = parent_relpath;
2098
2209
working_node->changed_rev = SVN_INVALID_REVNUM;
2099
working_node->last_mod_time = entry->text_time;
2100
working_node->translated_size = entry->working_size;
2210
working_node->recorded_time = entry->text_time;
2211
working_node->recorded_size = entry->working_size;
2102
2213
if (entry->depth != svn_depth_exclude)
2103
2214
working_node->depth = entry->depth;
2201
2312
actual_node->local_relpath = local_relpath;
2202
2313
actual_node->parent_relpath = parent_relpath;
2204
SVN_ERR(insert_actual_node(sdb, actual_node, scratch_pool));
2315
SVN_ERR(insert_actual_node(sdb, db, tmp_entry_abspath,
2316
actual_node, scratch_pool));
2207
2319
if (entry_node)
2247
2361
actual_node->parent_relpath = parent_relpath;
2248
2362
actual_node->tree_conflict_data = svn__apr_hash_index_val(hi);
2250
SVN_ERR(insert_actual_node(sdb, actual_node, scratch_pool));
2364
SVN_ERR(insert_actual_node(sdb, db, wri_abspath, actual_node,
2253
2368
return SVN_NO_ERROR;
2275
2390
struct write_baton *dir_node;
2277
2392
/* Get a copy of the "this dir" entry for comparison purposes. */
2278
this_dir = apr_hash_get(entries, SVN_WC_ENTRY_THIS_DIR,
2279
APR_HASH_KEY_STRING);
2393
this_dir = svn_hash_gets(entries, SVN_WC_ENTRY_THIS_DIR);
2281
2395
/* If there is no "this dir" entry, something is wrong. */
2282
2396
if (! this_dir)
2307
2421
const svn_wc_entry_t *this_entry = svn__apr_hash_index_val(hi);
2308
2422
const char *child_abspath, *child_relpath;
2309
2423
svn_wc__text_base_info_t *text_base_info
2310
= apr_hash_get(text_bases_info, name, APR_HASH_KEY_STRING);
2424
= svn_hash_gets(text_bases_info, name);
2312
2426
svn_pool_clear(iterpool);
2331
2445
if (dir_node->tree_conflicts)
2332
SVN_ERR(write_actual_only_entries(dir_node->tree_conflicts, sdb,
2333
wc_id, dir_relpath, iterpool));
2446
SVN_ERR(write_actual_only_entries(dir_node->tree_conflicts, sdb, db,
2447
new_root_abspath, wc_id, dir_relpath,
2335
2450
*dir_baton = dir_node;
2336
2451
svn_pool_destroy(iterpool);
2425
2540
svn_error_t *err;
2426
2541
svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
2428
err = svn_wc_entries_read(&entries, adm_access, show_hidden, pool);
2543
err = svn_wc__entries_read_internal(&entries, adm_access, show_hidden,
2431
2547
SVN_ERR(walk_callbacks->handle_error(dirpath, err, walk_baton, pool));
2433
2549
/* As promised, always return the '.' entry first. */
2434
dot_entry = apr_hash_get(entries, SVN_WC_ENTRY_THIS_DIR,
2435
APR_HASH_KEY_STRING);
2550
dot_entry = svn_hash_gets(entries, SVN_WC_ENTRY_THIS_DIR);
2436
2551
if (! dot_entry)
2437
2552
return walk_callbacks->handle_error
2438
2553
(dirpath, svn_error_createf(SVN_ERR_ENTRY_NOT_FOUND, NULL,
2610
2725
return SVN_NO_ERROR;
2613
if (kind == svn_wc__db_kind_dir)
2728
if (kind == svn_node_dir)
2614
2729
return walker_helper(path, adm_access, walk_callbacks, walk_baton,
2615
2730
walk_depth, show_hidden, cancel_func, cancel_baton,
added
removed
subversion/libsvn_wc/entries.c
