← Back to branch summary

~svn/ubuntu/oneiric/subversion/ppa

« back to all changes in this revision

Viewing changes to subversion/libsvn_subr/sorts.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2006-12-13 17:57:16 UTC
  • mfrom: (1.1.6 upstream) (0.1.3 etch)
  • Revision ID: james.westby@ubuntu.com-20061213175716-2ysv6z4w5dpa2r2f
Tags: 1.4.2dfsg1-2ubuntu1
* Merge with Debian unstable; remaining changes:
  - Create pot file on build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
subversion/libsvn_subr/sorts.c
2
2
 * sorts.c:   all sorts of sorts
3
3
 *
4
4
 * ====================================================================
5
 
 * Copyright (c) 2000-2004 CollabNet.  All rights reserved.
 
5
 * Copyright (c) 2000-2006 CollabNet.  All rights reserved.
6
6
 *
7
7
 * This software is licensed as described in the file COPYING, which
8
8
 * you should have received as part of this distribution.  The terms
60
60
 
61
61
 
62
62
int
63
 
svn_sort_compare_items_as_paths (const svn_sort__item_t *a,
64
 
                                 const svn_sort__item_t *b)
 
63
svn_sort_compare_items_as_paths(const svn_sort__item_t *a,
 
64
                                const svn_sort__item_t *b)
65
65
{
66
66
  const char *astr, *bstr;
67
67
 
69
69
  bstr = b->key;
70
70
  assert(astr[a->klen] == '\0');
71
71
  assert(bstr[b->klen] == '\0');
72
 
  return svn_path_compare_paths (astr, bstr);
 
72
  return svn_path_compare_paths(astr, bstr);
73
73
}
74
74
 
75
75
 
76
76
int
77
 
svn_sort_compare_items_lexically (const svn_sort__item_t *a,
78
 
                                  const svn_sort__item_t *b)
 
77
svn_sort_compare_items_lexically(const svn_sort__item_t *a,
 
78
                                 const svn_sort__item_t *b)
79
79
{
80
80
  int val;
81
81
  apr_size_t len;
82
82
 
83
83
  /* Compare bytes of a's key and b's key up to the common length. */
84
84
  len = (a->klen < b->klen) ? a->klen : b->klen;
85
 
  val = memcmp (a->key, b->key, len);
 
85
  val = memcmp(a->key, b->key, len);
86
86
  if (val != 0)
87
87
    return val;
88
88
 
92
92
 
93
93
 
94
94
int
95
 
svn_sort_compare_revisions (const void *a, const void *b)
 
95
svn_sort_compare_revisions(const void *a, const void *b)
96
96
{
97
97
  svn_revnum_t a_rev = *(const svn_revnum_t *)a;
98
98
  svn_revnum_t b_rev = *(const svn_revnum_t *)b;
105
105
 
106
106
 
107
107
int 
108
 
svn_sort_compare_paths (const void *a, const void *b)
 
108
svn_sort_compare_paths(const void *a, const void *b)
109
109
{
110
110
  const char *item1 = *((const char * const *) a);
111
111
  const char *item2 = *((const char * const *) b);
112
112
 
113
 
  return svn_path_compare_paths (item1, item2);
 
113
  return svn_path_compare_paths(item1, item2);
114
114
}
115
115
 
116
116
 
117
117
 
118
118
apr_array_header_t *
119
 
svn_sort__hash (apr_hash_t *ht,
120
 
                int (*comparison_func) (const svn_sort__item_t *,
121
 
                                        const svn_sort__item_t *),
122
 
                apr_pool_t *pool)
 
119
svn_sort__hash(apr_hash_t *ht,
 
120
               int (*comparison_func)(const svn_sort__item_t *,
 
121
                                      const svn_sort__item_t *),
 
122
               apr_pool_t *pool)
123
123
{
124
124
  apr_hash_index_t *hi;
125
125
  apr_array_header_t *ary;
126
126
 
127
 
  /* allocate an array with only one element to begin with. */
128
 
  ary = apr_array_make (pool, 1, sizeof(svn_sort__item_t));
 
127
  /* allocate an array with enough elements to hold all the keys. */
 
128
  ary = apr_array_make(pool, apr_hash_count(ht), sizeof(svn_sort__item_t));
129
129
 
130
130
  /* loop over hash table and push all keys into the array */
131
 
  for (hi = apr_hash_first (pool, ht); hi; hi = apr_hash_next (hi))
 
131
  for (hi = apr_hash_first(pool, ht); hi; hi = apr_hash_next(hi))
132
132
    {
133
 
      svn_sort__item_t *item = apr_array_push (ary);
 
133
      svn_sort__item_t *item = apr_array_push(ary);
134
134
 
135
 
      apr_hash_this (hi, &item->key, &item->klen, &item->value);
 
135
      apr_hash_this(hi, &item->key, &item->klen, &item->value);
136
136
    }
137
137
  
138
138
  /* now quicksort the array.  */
139
 
  qsort (ary->elts, ary->nelts, ary->elt_size,
140
 
         (int (*)(const void *, const void *))comparison_func);
 
139
  qsort(ary->elts, ary->nelts, ary->elt_size,
 
140
        (int (*)(const void *, const void *))comparison_func);
141
141
 
142
142
  return ary;
143
143
}
147
147
/** Sorting properties **/
148
148
 
149
149
svn_boolean_t
150
 
svn_prop_is_svn_prop (const char *prop_name)
 
150
svn_prop_is_svn_prop(const char *prop_name)
151
151
{
152
 
  return strncmp (prop_name, SVN_PROP_PREFIX, (sizeof (SVN_PROP_PREFIX) - 1)) 
 
152
  return strncmp(prop_name, SVN_PROP_PREFIX, (sizeof(SVN_PROP_PREFIX) - 1)) 
153
153
         ? FALSE 
154
154
         : TRUE;
155
155
}
156
156
 
157
157
 
158
158
svn_prop_kind_t
159
 
svn_property_kind (int *prefix_len,
160
 
                   const char *prop_name)
 
159
svn_property_kind(int *prefix_len,
 
160
                  const char *prop_name)
161
161
{
162
 
  apr_size_t wc_prefix_len = sizeof (SVN_PROP_WC_PREFIX) - 1;
163
 
  apr_size_t entry_prefix_len = sizeof (SVN_PROP_ENTRY_PREFIX) - 1;
 
162
  apr_size_t wc_prefix_len = sizeof(SVN_PROP_WC_PREFIX) - 1;
 
163
  apr_size_t entry_prefix_len = sizeof(SVN_PROP_ENTRY_PREFIX) - 1;
164
164
 
165
 
  if (strncmp (prop_name, SVN_PROP_WC_PREFIX, wc_prefix_len) == 0)
 
165
  if (strncmp(prop_name, SVN_PROP_WC_PREFIX, wc_prefix_len) == 0)
166
166
    {
167
167
      if (prefix_len)
168
168
        *prefix_len = wc_prefix_len;
169
169
      return svn_prop_wc_kind;     
170
170
    }
171
171
 
172
 
  if (strncmp (prop_name, SVN_PROP_ENTRY_PREFIX, entry_prefix_len) == 0)
 
172
  if (strncmp(prop_name, SVN_PROP_ENTRY_PREFIX, entry_prefix_len) == 0)
173
173
    {
174
174
      if (prefix_len)
175
175
        *prefix_len = entry_prefix_len;
184
184
 
185
185
 
186
186
svn_error_t *
187
 
svn_categorize_props (const apr_array_header_t *proplist,
188
 
                      apr_array_header_t **entry_props,
189
 
                      apr_array_header_t **wc_props,
190
 
                      apr_array_header_t **regular_props,
191
 
                      apr_pool_t *pool)
 
187
svn_categorize_props(const apr_array_header_t *proplist,
 
188
                     apr_array_header_t **entry_props,
 
189
                     apr_array_header_t **wc_props,
 
190
                     apr_array_header_t **regular_props,
 
191
                     apr_pool_t *pool)
192
192
{
193
193
  int i;
194
194
  if (entry_props)
195
 
    *entry_props = apr_array_make (pool, 1, sizeof (svn_prop_t));
 
195
    *entry_props = apr_array_make(pool, 1, sizeof(svn_prop_t));
196
196
  if (wc_props)
197
 
    *wc_props = apr_array_make (pool, 1, sizeof (svn_prop_t));
 
197
    *wc_props = apr_array_make(pool, 1, sizeof(svn_prop_t));
198
198
  if (regular_props)
199
 
    *regular_props = apr_array_make (pool, 1, sizeof (svn_prop_t));
 
199
    *regular_props = apr_array_make(pool, 1, sizeof(svn_prop_t));
200
200
 
201
201
  for (i = 0; i < proplist->nelts; i++)
202
202
    {
203
203
      svn_prop_t *prop, *newprop;
204
204
      enum svn_prop_kind kind;
205
205
      
206
 
      prop = &APR_ARRAY_IDX (proplist, i, svn_prop_t);      
207
 
      kind = svn_property_kind (NULL, prop->name);
 
206
      prop = &APR_ARRAY_IDX(proplist, i, svn_prop_t);      
 
207
      kind = svn_property_kind(NULL, prop->name);
208
208
      newprop = NULL;
209
209
 
210
210
      if (kind == svn_prop_regular_kind)
211
211
        {
212
212
          if (regular_props)
213
 
            newprop = apr_array_push (*regular_props);
 
213
            newprop = apr_array_push(*regular_props);
214
214
        }
215
215
      else if (kind == svn_prop_wc_kind)
216
216
        {
217
217
          if (wc_props)
218
 
            newprop = apr_array_push (*wc_props);
 
218
            newprop = apr_array_push(*wc_props);
219
219
        }
220
220
      else if (kind == svn_prop_entry_kind)
221
221
        {
222
222
          if (entry_props)
223
 
            newprop = apr_array_push (*entry_props);
 
223
            newprop = apr_array_push(*entry_props);
224
224
        }
225
225
      else
226
226
        /* Technically this can't happen, but might as well have the
227
227
           code ready in case that ever changes. */
228
 
        return svn_error_createf (SVN_ERR_BAD_PROP_KIND, NULL,
229
 
                                  "Bad property kind for property '%s'",
230
 
                                  prop->name);
 
228
        return svn_error_createf(SVN_ERR_BAD_PROP_KIND, NULL,
 
229
                                 "Bad property kind for property '%s'",
 
230
                                 prop->name);
231
231
 
232
232
      if (newprop)
233
233
        {
241
241
 
242
242
 
243
243
svn_error_t *
244
 
svn_prop_diffs (apr_array_header_t **propdiffs,
245
 
                apr_hash_t *target_props,
246
 
                apr_hash_t *source_props,
247
 
                apr_pool_t *pool)
 
244
svn_prop_diffs(apr_array_header_t **propdiffs,
 
245
               apr_hash_t *target_props,
 
246
               apr_hash_t *source_props,
 
247
               apr_pool_t *pool)
248
248
{
249
249
  apr_hash_index_t *hi;
250
 
  apr_array_header_t *ary = apr_array_make (pool, 1, sizeof (svn_prop_t));
 
250
  apr_array_header_t *ary = apr_array_make(pool, 1, sizeof(svn_prop_t));
251
251
 
252
252
  /* Note: we will be storing the pointers to the keys (from the hashes)
253
253
     into the propdiffs array.  It is acceptable for us to
255
255
 
256
256
  /* Loop over SOURCE_PROPS and examine each key.  This will allow us to
257
257
     detect any `deletion' events or `set-modification' events.  */
258
 
  for (hi = apr_hash_first (pool, source_props); hi; hi = apr_hash_next (hi))
 
258
  for (hi = apr_hash_first(pool, source_props); hi; hi = apr_hash_next(hi))
259
259
    {
260
260
      const void *key;
261
261
      apr_ssize_t klen;
263
263
      const svn_string_t *propval1, *propval2;
264
264
 
265
265
      /* Get next property */
266
 
      apr_hash_this (hi, &key, &klen, &val);
 
266
      apr_hash_this(hi, &key, &klen, &val);
267
267
      propval1 = val;
268
268
 
269
269
      /* Does property name exist in TARGET_PROPS? */
270
 
      propval2 = apr_hash_get (target_props, key, klen);
 
270
      propval2 = apr_hash_get(target_props, key, klen);
271
271
 
272
272
      if (propval2 == NULL)
273
273
        {
274
274
          /* Add a delete event to the array */
275
 
          svn_prop_t *p = apr_array_push (ary);
 
275
          svn_prop_t *p = apr_array_push(ary);
276
276
          p->name = key;
277
277
          p->value = NULL;
278
278
        }
279
 
      else if (! svn_string_compare (propval1, propval2))
 
279
      else if (! svn_string_compare(propval1, propval2))
280
280
        {
281
281
          /* Add a set (modification) event to the array */
282
 
          svn_prop_t *p = apr_array_push (ary);
 
282
          svn_prop_t *p = apr_array_push(ary);
283
283
          p->name = key;
284
 
          p->value = svn_string_dup (propval2, pool);
 
284
          p->value = svn_string_dup(propval2, pool);
285
285
        }
286
286
    }
287
287
 
288
288
  /* Loop over TARGET_PROPS and examine each key.  This allows us to
289
289
     detect `set-creation' events */
290
 
  for (hi = apr_hash_first (pool, target_props); hi; hi = apr_hash_next (hi))
 
290
  for (hi = apr_hash_first(pool, target_props); hi; hi = apr_hash_next(hi))
291
291
    {
292
292
      const void *key;
293
293
      apr_ssize_t klen;
295
295
      const svn_string_t *propval;
296
296
 
297
297
      /* Get next property */
298
 
      apr_hash_this (hi, &key, &klen, &val);
 
298
      apr_hash_this(hi, &key, &klen, &val);
299
299
      propval = val;
300
300
 
301
301
      /* Does property name exist in SOURCE_PROPS? */
302
 
      if (NULL == apr_hash_get (source_props, key, klen))
 
302
      if (NULL == apr_hash_get(source_props, key, klen))
303
303
        {
304
304
          /* Add a set (creation) event to the array */
305
 
          svn_prop_t *p = apr_array_push (ary);
 
305
          svn_prop_t *p = apr_array_push(ary);
306
306
          p->name = key;
307
 
          p->value = svn_string_dup (propval, pool);
 
307
          p->value = svn_string_dup(propval, pool);
308
308
        }
309
309
    }
310
310
 
316
316
 
317
317
 
318
318
svn_boolean_t
319
 
svn_prop_needs_translation (const char *propname)
 
319
svn_prop_needs_translation(const char *propname)
320
320
{
321
321
  /* ### Someday, we may want to be picky and choosy about which
322
322
     properties require UTF8 and EOL conversion.  For now, all "svn:"
323
323
     props need it.  */
324
324
 
325
 
  return svn_prop_is_svn_prop (propname);
 
325
  return svn_prop_is_svn_prop(propname);
326
326
}