1/* 2 * deprecated.c: holding file for all deprecated APIs. 3 * "we can't lose 'em, but we can shun 'em!" 4 * 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 13 * 14 * http://www.apache.org/licenses/LICENSE-2.0 15 * 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 21 * under the License. 22 * ==================================================================== 23 */ 24 25/* ==================================================================== */ 26 27 28 29/*** Includes. ***/ 30 31/* We define this here to remove any further warnings about the usage of 32 deprecated functions in this file. */ 33#define SVN_DEPRECATED 34 35#include "svn_diff.h" 36#include "svn_utf.h" 37 38#include "svn_private_config.h" 39 40 41 42 43/*** Code. ***/ 44struct fns_wrapper_baton 45{ 46 /* We put the old baton in front of this one, so that we can still use 47 this baton in place of the old. This prevents us from having to 48 implement simple wrappers around each member of diff_fns_t. */ 49 void *old_baton; 50 const svn_diff_fns_t *vtable; 51}; 52 53static svn_error_t * 54datasources_open(void *baton, 55 apr_off_t *prefix_lines, 56 apr_off_t *suffix_lines, 57 const svn_diff_datasource_e *datasources, 58 apr_size_t datasource_len) 59{ 60 struct fns_wrapper_baton *fwb = baton; 61 apr_size_t i; 62 63 /* Just iterate over the datasources, using the old singular version. */ 64 for (i = 0; i < datasource_len; i++) 65 { 66 SVN_ERR(fwb->vtable->datasource_open(fwb->old_baton, datasources[i])); 67 } 68 69 /* Don't claim any prefix or suffix matches. */ 70 *prefix_lines = 0; 71 *suffix_lines = 0; 72 73 return SVN_NO_ERROR; 74} 75 76static svn_error_t * 77datasource_close(void *baton, 78 svn_diff_datasource_e datasource) 79{ 80 struct fns_wrapper_baton *fwb = baton; 81 return fwb->vtable->datasource_close(fwb->old_baton, datasource); 82} 83 84static svn_error_t * 85datasource_get_next_token(apr_uint32_t *hash, 86 void **token, 87 void *baton, 88 svn_diff_datasource_e datasource) 89{ 90 struct fns_wrapper_baton *fwb = baton; 91 return fwb->vtable->datasource_get_next_token(hash, token, fwb->old_baton, 92 datasource); 93} 94 95static svn_error_t * 96token_compare(void *baton, 97 void *ltoken, 98 void *rtoken, 99 int *compare) 100{ 101 struct fns_wrapper_baton *fwb = baton; 102 return fwb->vtable->token_compare(fwb->old_baton, ltoken, rtoken, compare); 103} 104 105static void 106token_discard(void *baton, 107 void *token) 108{ 109 struct fns_wrapper_baton *fwb = baton; 110 fwb->vtable->token_discard(fwb->old_baton, token); 111} 112 113static void 114token_discard_all(void *baton) 115{ 116 struct fns_wrapper_baton *fwb = baton; 117 fwb->vtable->token_discard_all(fwb->old_baton); 118} 119 120 121static void 122wrap_diff_fns(svn_diff_fns2_t **diff_fns2, 123 struct fns_wrapper_baton **baton2, 124 const svn_diff_fns_t *diff_fns, 125 void *baton, 126 apr_pool_t *result_pool) 127{ 128 /* Initialize the return vtable. */ 129 *diff_fns2 = apr_palloc(result_pool, sizeof(**diff_fns2)); 130 131 (*diff_fns2)->datasources_open = datasources_open; 132 (*diff_fns2)->datasource_close = datasource_close; 133 (*diff_fns2)->datasource_get_next_token = datasource_get_next_token; 134 (*diff_fns2)->token_compare = token_compare; 135 (*diff_fns2)->token_discard = token_discard; 136 (*diff_fns2)->token_discard_all = token_discard_all; 137 138 /* Initialize the wrapper baton. */ 139 *baton2 = apr_palloc(result_pool, sizeof (**baton2)); 140 (*baton2)->old_baton = baton; 141 (*baton2)->vtable = diff_fns; 142} 143 144 145/*** From diff_file.c ***/ 146 147svn_error_t * 148svn_diff_file_output_unified3(svn_stream_t *output_stream, 149 svn_diff_t *diff, 150 const char *original_path, 151 const char *modified_path, 152 const char *original_header, 153 const char *modified_header, 154 const char *header_encoding, 155 const char *relative_to_dir, 156 svn_boolean_t show_c_function, 157 apr_pool_t *pool) 158{ 159 return svn_error_trace( 160 svn_diff_file_output_unified4(output_stream, 161 diff, 162 original_path, 163 modified_path, 164 original_header, 165 modified_header, 166 header_encoding, 167 relative_to_dir, 168 show_c_function, 169 -1 /* context_size */, 170 NULL, NULL, /* cancel */ 171 pool)); 172} 173 174svn_error_t * 175svn_diff_file_output_unified2(svn_stream_t *output_stream, 176 svn_diff_t *diff, 177 const char *original_path, 178 const char *modified_path, 179 const char *original_header, 180 const char *modified_header, 181 const char *header_encoding, 182 apr_pool_t *pool) 183{ 184 return svn_diff_file_output_unified3(output_stream, diff, 185 original_path, modified_path, 186 original_header, modified_header, 187 header_encoding, NULL, FALSE, pool); 188} 189 190svn_error_t * 191svn_diff_file_output_unified(svn_stream_t *output_stream, 192 svn_diff_t *diff, 193 const char *original_path, 194 const char *modified_path, 195 const char *original_header, 196 const char *modified_header, 197 apr_pool_t *pool) 198{ 199 return svn_diff_file_output_unified2(output_stream, diff, 200 original_path, modified_path, 201 original_header, modified_header, 202 SVN_APR_LOCALE_CHARSET, pool); 203} 204 205svn_error_t * 206svn_diff_file_diff(svn_diff_t **diff, 207 const char *original, 208 const char *modified, 209 apr_pool_t *pool) 210{ 211 return svn_diff_file_diff_2(diff, original, modified, 212 svn_diff_file_options_create(pool), pool); 213} 214 215svn_error_t * 216svn_diff_file_diff3(svn_diff_t **diff, 217 const char *original, 218 const char *modified, 219 const char *latest, 220 apr_pool_t *pool) 221{ 222 return svn_diff_file_diff3_2(diff, original, modified, latest, 223 svn_diff_file_options_create(pool), pool); 224} 225 226svn_error_t * 227svn_diff_file_diff4(svn_diff_t **diff, 228 const char *original, 229 const char *modified, 230 const char *latest, 231 const char *ancestor, 232 apr_pool_t *pool) 233{ 234 return svn_diff_file_diff4_2(diff, original, modified, latest, ancestor, 235 svn_diff_file_options_create(pool), pool); 236} 237 238svn_error_t * 239svn_diff_file_output_merge(svn_stream_t *output_stream, 240 svn_diff_t *diff, 241 const char *original_path, 242 const char *modified_path, 243 const char *latest_path, 244 const char *conflict_original, 245 const char *conflict_modified, 246 const char *conflict_latest, 247 const char *conflict_separator, 248 svn_boolean_t display_original_in_conflict, 249 svn_boolean_t display_resolved_conflicts, 250 apr_pool_t *pool) 251{ 252 svn_diff_conflict_display_style_t style = 253 svn_diff_conflict_display_modified_latest; 254 255 if (display_resolved_conflicts) 256 style = svn_diff_conflict_display_resolved_modified_latest; 257 258 if (display_original_in_conflict) 259 style = svn_diff_conflict_display_modified_original_latest; 260 261 return svn_diff_file_output_merge2(output_stream, 262 diff, 263 original_path, 264 modified_path, 265 latest_path, 266 conflict_original, 267 conflict_modified, 268 conflict_latest, 269 conflict_separator, 270 style, 271 pool); 272} 273 274svn_error_t * 275svn_diff_file_output_merge2(svn_stream_t *output_stream, 276 svn_diff_t *diff, 277 const char *original_path, 278 const char *modified_path, 279 const char *latest_path, 280 const char *conflict_original, 281 const char *conflict_modified, 282 const char *conflict_latest, 283 const char *conflict_separator, 284 svn_diff_conflict_display_style_t conflict_style, 285 apr_pool_t *pool) 286{ 287 return svn_error_trace(svn_diff_file_output_merge3(output_stream, 288 diff, original_path, 289 modified_path, 290 latest_path, 291 conflict_original, 292 conflict_modified, 293 conflict_latest, 294 conflict_separator, 295 conflict_style, 296 NULL, NULL, /* cancel */ 297 pool)); 298} 299 300/*** From diff.c ***/ 301svn_error_t * 302svn_diff_diff(svn_diff_t **diff, 303 void *diff_baton, 304 const svn_diff_fns_t *vtable, 305 apr_pool_t *pool) 306{ 307 svn_diff_fns2_t *diff_fns2; 308 struct fns_wrapper_baton *fwb; 309 310 wrap_diff_fns(&diff_fns2, &fwb, vtable, diff_baton, pool); 311 return svn_diff_diff_2(diff, fwb, diff_fns2, pool); 312} 313 314 315/*** From diff3.c ***/ 316svn_error_t * 317svn_diff_diff3(svn_diff_t **diff, 318 void *diff_baton, 319 const svn_diff_fns_t *vtable, 320 apr_pool_t *pool) 321{ 322 svn_diff_fns2_t *diff_fns2; 323 struct fns_wrapper_baton *fwb; 324 325 wrap_diff_fns(&diff_fns2, &fwb, vtable, diff_baton, pool); 326 return svn_diff_diff3_2(diff, fwb, diff_fns2, pool); 327} 328 329 330/*** From diff4.c ***/ 331svn_error_t * 332svn_diff_diff4(svn_diff_t **diff, 333 void *diff_baton, 334 const svn_diff_fns_t *vtable, 335 apr_pool_t *pool) 336{ 337 svn_diff_fns2_t *diff_fns2; 338 struct fns_wrapper_baton *fwb; 339 340 wrap_diff_fns(&diff_fns2, &fwb, vtable, diff_baton, pool); 341 return svn_diff_diff4_2(diff, fwb, diff_fns2, pool); 342} 343 344/*** From util.c ***/ 345svn_error_t * 346svn_diff_output(svn_diff_t *diff, 347 void *output_baton, 348 const svn_diff_output_fns_t *output_fns) 349{ 350 return svn_error_trace(svn_diff_output2(diff, output_baton, output_fns, 351 NULL, NULL /* cancel */)); 352} 353 354/*** From diff_memory.c ***/ 355svn_error_t * 356svn_diff_mem_string_output_merge(svn_stream_t *output_stream, 357 svn_diff_t *diff, 358 const svn_string_t *original, 359 const svn_string_t *modified, 360 const svn_string_t *latest, 361 const char *conflict_original, 362 const char *conflict_modified, 363 const char *conflict_latest, 364 const char *conflict_separator, 365 svn_boolean_t display_original_in_conflict, 366 svn_boolean_t display_resolved_conflicts, 367 apr_pool_t *pool) 368{ 369 svn_diff_conflict_display_style_t style = 370 svn_diff_conflict_display_modified_latest; 371 372 if (display_resolved_conflicts) 373 style = svn_diff_conflict_display_resolved_modified_latest; 374 375 if (display_original_in_conflict) 376 style = svn_diff_conflict_display_modified_original_latest; 377 378 return svn_diff_mem_string_output_merge2(output_stream, 379 diff, 380 original, 381 modified, 382 latest, 383 conflict_original, 384 conflict_modified, 385 conflict_latest, 386 conflict_separator, 387 style, 388 pool); 389} 390 391svn_error_t * 392svn_diff_mem_string_output_merge2(svn_stream_t *output_stream, 393 svn_diff_t *diff, 394 const svn_string_t *original, 395 const svn_string_t *modified, 396 const svn_string_t *latest, 397 const char *conflict_original, 398 const char *conflict_modified, 399 const char *conflict_latest, 400 const char *conflict_separator, 401 svn_diff_conflict_display_style_t style, 402 apr_pool_t *pool) 403{ 404 return svn_error_trace(svn_diff_mem_string_output_merge3(output_stream, diff, 405 original, 406 modified, latest, 407 conflict_original, 408 conflict_modified, 409 conflict_latest, 410 conflict_separator, 411 style, 412 /* no cancelation */ 413 NULL, NULL, 414 pool)); 415} 416 417svn_error_t * 418svn_diff_mem_string_output_unified(svn_stream_t *output_stream, 419 svn_diff_t *diff, 420 const char *original_header, 421 const char *modified_header, 422 const char *header_encoding, 423 const svn_string_t *original, 424 const svn_string_t *modified, 425 apr_pool_t *pool) 426{ 427 return svn_error_trace(svn_diff_mem_string_output_unified2(output_stream, 428 diff, 429 TRUE, 430 NULL, 431 original_header, 432 modified_header, 433 header_encoding, 434 original, 435 modified, 436 pool)); 437} 438 439svn_error_t * 440svn_diff_mem_string_output_unified2(svn_stream_t *output_stream, 441 svn_diff_t *diff, 442 svn_boolean_t with_diff_header, 443 const char *hunk_delimiter, 444 const char *original_header, 445 const char *modified_header, 446 const char *header_encoding, 447 const svn_string_t *original, 448 const svn_string_t *modified, 449 apr_pool_t *pool) 450{ 451 return svn_error_trace(svn_diff_mem_string_output_unified3(output_stream, 452 diff, 453 with_diff_header, 454 hunk_delimiter, 455 original_header, 456 modified_header, 457 header_encoding, 458 original, 459 modified, 460 -1 /* context */, 461 /* cancel */ 462 NULL, NULL, 463 pool)); 464} 465