/** * @copyright * ==================================================================== * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * ==================================================================== * @endcopyright * * @file svn_diff.h * @brief Contextual diffing. * * This is an internalized library for performing contextual diffs * between sources of data. * * @note This is different than Subversion's binary-diffing engine. * That API lives in @c svn_delta.h -- see the "text deltas" section. A * "text delta" is way of representing precise binary diffs between * strings of data. The Subversion client and server send text deltas * to one another during updates and commits. * * This API, however, is (or will be) used for performing *contextual* * merges between files in the working copy. During an update or * merge, 3-way file merging is needed. And 'svn diff' needs to show * the differences between 2 files. * * The nice thing about this API is that it's very general. It * operates on any source of data (a "datasource") and calculates * contextual differences on "tokens" within the data. In our * particular usage, the datasources are files and the tokens are * lines. But the possibilities are endless. */ #ifndef SVN_DIFF_H #define SVN_DIFF_H #include <apr.h> #include <apr_pools.h> #include <apr_tables.h> /* for apr_array_header_t */ #include "svn_types.h" #include "svn_io.h" /* for svn_stream_t */ #include "svn_string.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ /** * Get libsvn_diff version information. * * @since New in 1.1. */ const svn_version_t * svn_diff_version(void); /* Diffs. */ /** An opaque type that represents a difference between either two or * three datasources. This object is returned by svn_diff_diff(), * svn_diff_diff3() and svn_diff_diff4(), and consumed by a number of * other routines. */ typedef struct svn_diff_t svn_diff_t; /** * There are four types of datasources. In GNU diff3 terminology, * the first three types correspond to the phrases "older", "mine", * and "yours". */ typedef enum svn_diff_datasource_e { /** The oldest form of the data. */ svn_diff_datasource_original, /** The same data, but potentially changed by the user. */ svn_diff_datasource_modified, /** The latest version of the data, possibly different than the * user's modified version. */ svn_diff_datasource_latest, /** The common ancestor of original and modified. */ svn_diff_datasource_ancestor } svn_diff_datasource_e; /** A vtable for reading data from the three datasources. * @since New in 1.7. */ typedef struct svn_diff_fns2_t { /** Open the datasources of type @a datasources. */ svn_error_t *(*datasources_open)(void *diff_baton, apr_off_t *prefix_lines, apr_off_t *suffix_lines, const svn_diff_datasource_e *datasources, apr_size_t datasources_len); /** Close the datasource of type @a datasource. */ svn_error_t *(*datasource_close)(void *diff_baton, svn_diff_datasource_e datasource); /** Get the next "token" from the datasource of type @a datasource. * Return a "token" in @a *token. Return a hash of "token" in @a *hash. * Leave @a token and @a hash untouched when the datasource is exhausted. */ svn_error_t *(*datasource_get_next_token)(apr_uint32_t *hash, void **token, void *diff_baton, svn_diff_datasource_e datasource); /** A function for ordering the tokens, resembling 'strcmp' in functionality. * @a compare should contain the return value of the comparison: * If @a ltoken and @a rtoken are "equal", return 0. If @a ltoken is * "less than" @a rtoken, return a number < 0. If @a ltoken is * "greater than" @a rtoken, return a number > 0. */ svn_error_t *(*token_compare)(void *diff_baton, void *ltoken, void *rtoken, int *compare); /** Free @a token from memory, the diff algorithm is done with it. */ void (*token_discard)(void *diff_baton, void *token); /** Free *all* tokens from memory, they're no longer needed. */ void (*token_discard_all)(void *diff_baton); } svn_diff_fns2_t; /** Like #svn_diff_fns2_t except with datasource_open() instead of * datasources_open(). * * @deprecated Provided for backward compatibility with the 1.6 API. */ typedef struct svn_diff_fns_t { svn_error_t *(*datasource_open)(void *diff_baton, svn_diff_datasource_e datasource); svn_error_t *(*datasource_close)(void *diff_baton, svn_diff_datasource_e datasource); svn_error_t *(*datasource_get_next_token)(apr_uint32_t *hash, void **token, void *diff_baton, svn_diff_datasource_e datasource); svn_error_t *(*token_compare)(void *diff_baton, void *ltoken, void *rtoken, int *compare); void (*token_discard)(void *diff_baton, void *token); void (*token_discard_all)(void *diff_baton); } svn_diff_fns_t; /* The Main Events */ /** Given a vtable of @a diff_fns/@a diff_baton for reading datasources, * return a diff object in @a *diff that represents a difference between * an "original" and "modified" datasource. Do all allocation in @a pool. * * @since New in 1.7. */ svn_error_t * svn_diff_diff_2(svn_diff_t **diff, void *diff_baton, const svn_diff_fns2_t *diff_fns, apr_pool_t *pool); /** Like svn_diff_diff_2() but using #svn_diff_fns_t instead of * #svn_diff_fns2_t. * * @deprecated Provided for backward compatibility with the 1.6 API. */ SVN_DEPRECATED svn_error_t * svn_diff_diff(svn_diff_t **diff, void *diff_baton, const svn_diff_fns_t *diff_fns, apr_pool_t *pool); /** Given a vtable of @a diff_fns/@a diff_baton for reading datasources, * return a diff object in @a *diff that represents a difference between * three datasources: "original", "modified", and "latest". Do all * allocation in @a pool. * * @since New in 1.7. */ svn_error_t * svn_diff_diff3_2(svn_diff_t **diff, void *diff_baton, const svn_diff_fns2_t *diff_fns, apr_pool_t *pool); /** Like svn_diff_diff3_2() but using #svn_diff_fns_t instead of * #svn_diff_fns2_t. * * @deprecated Provided for backward compatibility with the 1.6 API. */ SVN_DEPRECATED svn_error_t * svn_diff_diff3(svn_diff_t **diff, void *diff_baton, const svn_diff_fns_t *diff_fns, apr_pool_t *pool); /** Given a vtable of @a diff_fns/@a diff_baton for reading datasources, * return a diff object in @a *diff that represents a difference between * two datasources: "original" and "latest", adjusted to become a full * difference between "original", "modified" and "latest" using "ancestor". * Do all allocation in @a pool. * * @since New in 1.7. */ svn_error_t * svn_diff_diff4_2(svn_diff_t **diff, void *diff_baton, const svn_diff_fns2_t *diff_fns, apr_pool_t *pool); /** Like svn_diff_diff4_2() but using #svn_diff_fns_t instead of * #svn_diff_fns2_t. * * @deprecated Provided for backward compatibility with the 1.6 API. */ SVN_DEPRECATED svn_error_t * svn_diff_diff4(svn_diff_t **diff, void *diff_baton, const svn_diff_fns_t *diff_fns, apr_pool_t *pool); /* Utility functions */ /** Determine if a diff object contains conflicts. If it does, return * @c TRUE, else return @c FALSE. */ svn_boolean_t svn_diff_contains_conflicts(svn_diff_t *diff); /** Determine if a diff object contains actual differences between the * datasources. If so, return @c TRUE, else return @c FALSE. */ svn_boolean_t svn_diff_contains_diffs(svn_diff_t *diff); /* Displaying Diffs */ /** A vtable for displaying (or consuming) differences between datasources. * * Differences, similarities, and conflicts are described by lining up * "ranges" of data. * * @note These callbacks describe data ranges in units of "tokens". * A "token" is whatever you've defined it to be in your datasource * @c svn_diff_fns_t vtable. */ typedef struct svn_diff_output_fns_t { /* Two-way and three-way diffs both call the first two output functions: */ /** * If doing a two-way diff, then an *identical* data range was found * between the "original" and "modified" datasources. Specifically, * the match starts at @a original_start and goes for @a original_length * tokens in the original data, and at @a modified_start for * @a modified_length tokens in the modified data. * * If doing a three-way diff, then all three datasources have * matching data ranges. The range @a latest_start, @a latest_length in * the "latest" datasource is identical to the range @a original_start, * @a original_length in the original data, and is also identical to * the range @a modified_start, @a modified_length in the modified data. */ svn_error_t *(*output_common)(void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length); /** * If doing a two-way diff, then an *conflicting* data range was found * between the "original" and "modified" datasources. Specifically, * the conflict starts at @a original_start and goes for @a original_length * tokens in the original data, and at @a modified_start for * @a modified_length tokens in the modified data. * * If doing a three-way diff, then an identical data range was discovered * between the "original" and "latest" datasources, but this conflicts with * a range in the "modified" datasource. */ svn_error_t *(*output_diff_modified)(void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length); /* ------ The following callbacks are used by three-way diffs only --- */ /** An identical data range was discovered between the "original" and * "modified" datasources, but this conflicts with a range in the * "latest" datasource. */ svn_error_t *(*output_diff_latest)(void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length); /** An identical data range was discovered between the "modified" and * "latest" datasources, but this conflicts with a range in the * "original" datasource. */ svn_error_t *(*output_diff_common)(void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length); /** All three datasources have conflicting data ranges. The range * @a latest_start, @a latest_length in the "latest" datasource conflicts * with the range @a original_start, @a original_length in the "original" * datasource, and also conflicts with the range @a modified_start, * @a modified_length in the "modified" datasource. * If there are common ranges in the "modified" and "latest" datasources * in this conflicting range, @a resolved_diff will contain a diff * which can be used to retrieve the common and conflicting ranges. */ svn_error_t *(*output_conflict)(void *output_baton, apr_off_t original_start, apr_off_t original_length, apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, apr_off_t latest_length, svn_diff_t *resolved_diff); } svn_diff_output_fns_t; /** Style for displaying conflicts during diff3 output. * * @since New in 1.6. */ typedef enum svn_diff_conflict_display_style_t { /** Display modified and latest, with conflict markers. */ svn_diff_conflict_display_modified_latest, /** Like svn_diff_conflict_display_modified_latest, but with an extra effort to identify common sequences between modified and latest. */ svn_diff_conflict_display_resolved_modified_latest, /** Display modified, original, and latest, with conflict markers. */ svn_diff_conflict_display_modified_original_latest, /** Just display modified, with no markers. */ svn_diff_conflict_display_modified, /** Just display latest, with no markers. */ svn_diff_conflict_display_latest, /** Like svn_diff_conflict_display_modified_original_latest, but *only* showing conflicts. */ svn_diff_conflict_display_only_conflicts } svn_diff_conflict_display_style_t; /** Given a vtable of @a output_fns/@a output_baton for consuming * differences, output the differences in @a diff. */ svn_error_t * svn_diff_output(svn_diff_t *diff, void *output_baton, const svn_diff_output_fns_t *output_fns); /* Diffs on files */ /** To what extent whitespace should be ignored when comparing lines. * * @since New in 1.4. */ typedef enum svn_diff_file_ignore_space_t { /** Ignore no whitespace. */ svn_diff_file_ignore_space_none, /** Ignore changes in sequences of whitespace characters, treating each * sequence of whitespace characters as a single space. */ svn_diff_file_ignore_space_change, /** Ignore all whitespace characters. */ svn_diff_file_ignore_space_all } svn_diff_file_ignore_space_t; /** Options to control the behaviour of the file diff routines. * * @since New in 1.4. * * @note This structure may be extended in the future, so to preserve binary * compatibility, users must not allocate structs of this type themselves. * @see svn_diff_file_options_create(). * * @note Although its name suggests otherwise, this structure is used to * pass options to file as well as in-memory diff functions. */ typedef struct svn_diff_file_options_t { /** To what extent whitespace should be ignored when comparing lines. * The default is @c svn_diff_file_ignore_space_none. */ svn_diff_file_ignore_space_t ignore_space; /** Whether to treat all end-of-line markers the same when comparing lines. * The default is @c FALSE. */ svn_boolean_t ignore_eol_style; /** Whether the "@@" lines of the unified diff output should include a prefix * of the nearest preceding line that starts with a character that might be * the initial character of a C language identifier. The default is * @c FALSE. */ svn_boolean_t show_c_function; } svn_diff_file_options_t; /** Allocate a @c svn_diff_file_options_t structure in @a pool, initializing * it with default values. * * @since New in 1.4. */ svn_diff_file_options_t * svn_diff_file_options_create(apr_pool_t *pool); /** * Parse @a args, an array of <tt>const char *</tt> command line switches * and adjust @a options accordingly. @a options is assumed to be initialized * with default values. @a pool is used for temporary allocation. * * @since New in 1.4. * * The following options are supported: * - --ignore-space-change, -b * - --ignore-all-space, -w * - --ignore-eol-style * - --unified, -u (for compatibility, does nothing). */ svn_error_t * svn_diff_file_options_parse(svn_diff_file_options_t *options, const apr_array_header_t *args, apr_pool_t *pool); /** A convenience function to produce a diff between two files. * * @since New in 1.4. * * Return a diff object in @a *diff (allocated from @a pool) that represents * the difference between an @a original file and @a modified file. * (The file arguments must be full paths to the files.) * * Compare lines according to the relevant fields of @a options. */ svn_error_t * svn_diff_file_diff_2(svn_diff_t **diff, const char *original, const char *modified, const svn_diff_file_options_t *options, apr_pool_t *pool); /** Similar to svn_file_diff_2(), but with @a options set to a struct with * default options. * * @deprecated Provided for backwards compatibility with the 1.3 API. */ SVN_DEPRECATED svn_error_t * svn_diff_file_diff(svn_diff_t **diff, const char *original, const char *modified, apr_pool_t *pool); /** A convenience function to produce a diff between three files. * * @since New in 1.4. * * Return a diff object in @a *diff (allocated from @a pool) that represents * the difference between an @a original file, @a modified file, and @a latest * file. * * Compare lines according to the relevant fields of @a options. */ svn_error_t * svn_diff_file_diff3_2(svn_diff_t **diff, const char *original, const char *modified, const char *latest, const svn_diff_file_options_t *options, apr_pool_t *pool); /** Similar to svn_diff_file_diff3_2(), but with @a options set to a struct * with default options. * * @deprecated Provided for backwards compatibility with the 1.3 API. */ SVN_DEPRECATED svn_error_t * svn_diff_file_diff3(svn_diff_t **diff, const char *original, const char *modified, const char *latest, apr_pool_t *pool); /** A convenience function to produce a diff between four files. * * @since New in 1.4. * * Return a diff object in @a *diff (allocated from @a pool) that represents * the difference between an @a original file, @a modified file, @a latest * and @a ancestor file. (The file arguments must be full paths to the files.) * * Compare lines according to the relevant fields of @a options. */ svn_error_t * svn_diff_file_diff4_2(svn_diff_t **diff, const char *original, const char *modified, const char *latest, const char *ancestor, const svn_diff_file_options_t *options, apr_pool_t *pool); /** Similar to svn_file_diff4_2(), but with @a options set to a struct with * default options. * * @deprecated Provided for backwards compatibility with the 1.3 API. */ SVN_DEPRECATED svn_error_t * svn_diff_file_diff4(svn_diff_t **diff, const char *original, const char *modified, const char *latest, const char *ancestor, apr_pool_t *pool); /** A convenience function to produce unified diff output from the * diff generated by svn_diff_file_diff(). * * @since New in 1.5. * * Output a @a diff between @a original_path and @a modified_path in unified * context diff format to @a output_stream. Optionally supply * @a original_header and/or @a modified_header to be displayed in the header * of the output. If @a original_header or @a modified_header is @c NULL, a * default header will be displayed, consisting of path and last modified time. * Output all headers and markers in @a header_encoding. If @a relative_to_dir * is not @c NULL, the @a original_path and @a modified_path will have the * @a relative_to_dir stripped from the front of the respective paths. If * @a relative_to_dir is @c NULL, paths will be not be modified. If * @a relative_to_dir is not @c NULL but @a relative_to_dir is not a parent * path of the target, an error is returned. Finally, if @a relative_to_dir * is a URL, an error will be returned. */ svn_error_t * svn_diff_file_output_unified3(svn_stream_t *output_stream, svn_diff_t *diff, const char *original_path, const char *modified_path, const char *original_header, const char *modified_header, const char *header_encoding, const char *relative_to_dir, svn_boolean_t show_c_function, apr_pool_t *pool); /** Similar to svn_diff_file_output_unified3(), but with @a relative_to_dir * set to NULL and @a show_c_function to false. * * @deprecated Provided for backwards compatibility with the 1.4 API. */ SVN_DEPRECATED svn_error_t * svn_diff_file_output_unified2(svn_stream_t *output_stream, svn_diff_t *diff, const char *original_path, const char *modified_path, const char *original_header, const char *modified_header, const char *header_encoding, apr_pool_t *pool); /** Similar to svn_diff_file_output_unified2(), but with @a header_encoding * set to @c APR_LOCALE_CHARSET. * * @deprecated Provided for backward compatibility with the 1.2 API. */ SVN_DEPRECATED svn_error_t * svn_diff_file_output_unified(svn_stream_t *output_stream, svn_diff_t *diff, const char *original_path, const char *modified_path, const char *original_header, const char *modified_header, apr_pool_t *pool); /** A convenience function to produce diff3 output from the * diff generated by svn_diff_file_diff3(). * * Output a @a diff between @a original_path, @a modified_path and * @a latest_path in merged format to @a output_stream. Optionally supply * @a conflict_modified, @a conflict_original, @a conflict_separator and/or * @a conflict_latest to be displayed as conflict markers in the output. * If @a conflict_original, @a conflict_modified, @a conflict_latest and/or * @a conflict_separator is @c NULL, a default marker will be displayed. * @a conflict_style dictates how conflicts are displayed. * * @since New in 1.6. */ svn_error_t * svn_diff_file_output_merge2(svn_stream_t *output_stream, svn_diff_t *diff, const char *original_path, const char *modified_path, const char *latest_path, const char *conflict_original, const char *conflict_modified, const char *conflict_latest, const char *conflict_separator, svn_diff_conflict_display_style_t conflict_style, apr_pool_t *pool); /** Similar to svn_diff_file_output_merge2, but with @a * display_original_in_conflict and @a display_resolved_conflicts * booleans instead of the @a conflict_style enum. * * If both booleans are false, acts like * svn_diff_conflict_display_modified_latest; if @a * display_original_in_conflict is true, acts like * svn_diff_conflict_display_modified_original_latest; if @a * display_resolved_conflicts is true, acts like * svn_diff_conflict_display_resolved_modified_latest. The booleans * may not both be true. * * @deprecated Provided for backward compatibility with the 1.5 API. */ SVN_DEPRECATED svn_error_t * svn_diff_file_output_merge(svn_stream_t *output_stream, svn_diff_t *diff, const char *original_path, const char *modified_path, const char *latest_path, const char *conflict_original, const char *conflict_modified, const char *conflict_latest, const char *conflict_separator, svn_boolean_t display_original_in_conflict, svn_boolean_t display_resolved_conflicts, apr_pool_t *pool); /* Diffs on in-memory structures */ /** Generate @a diff output from the @a original and @a modified * in-memory strings. @a diff will be allocated from @a pool. * * @since New in 1.5. */ svn_error_t * svn_diff_mem_string_diff(svn_diff_t **diff, const svn_string_t *original, const svn_string_t *modified, const svn_diff_file_options_t *options, apr_pool_t *pool); /** Generate @a diff output from the @a original, @a modified and @a latest * in-memory strings. @a diff will be allocated in @a pool. * * @since New in 1.5. */ svn_error_t * svn_diff_mem_string_diff3(svn_diff_t **diff, const svn_string_t *original, const svn_string_t *modified, const svn_string_t *latest, const svn_diff_file_options_t *options, apr_pool_t *pool); /** Generate @a diff output from the @a original, @a modified and @a latest * in-memory strings, using @a ancestor. @a diff will be allocated in @a pool. * * @since New in 1.5. */ svn_error_t * svn_diff_mem_string_diff4(svn_diff_t **diff, const svn_string_t *original, const svn_string_t *modified, const svn_string_t *latest, const svn_string_t *ancestor, const svn_diff_file_options_t *options, apr_pool_t *pool); /** Outputs the @a diff object generated by svn_diff_mem_string_diff() * in unified diff format on @a output_stream, using @a original * and @a modified for the text in the output. * A diff header is only written to the output if @a with_diff_header * is TRUE. * * Outputs the header and hunk delimiters in @a header_encoding. * A @a hunk_delimiter can optionally be specified. * If @a hunk_delimiter is NULL, use the default hunk delimiter "@@". * * @a original_header and @a modified header are * used to fill the field after the "---" and "+++" header markers. * * @since New in 1.7. */ svn_error_t * svn_diff_mem_string_output_unified2(svn_stream_t *output_stream, svn_diff_t *diff, svn_boolean_t with_diff_header, const char *hunk_delimiter, const char *original_header, const char *modified_header, const char *header_encoding, const svn_string_t *original, const svn_string_t *modified, apr_pool_t *pool); /** Similar to svn_diff_mem_string_output_unified2() but with * @a with_diff_header always set to TRUE and @a hunk_delimiter always * set to NULL. * * @since New in 1.5. */ svn_error_t * svn_diff_mem_string_output_unified(svn_stream_t *output_stream, svn_diff_t *diff, const char *original_header, const char *modified_header, const char *header_encoding, const svn_string_t *original, const svn_string_t *modified, apr_pool_t *pool); /** Output the @a diff generated by svn_diff_mem_string_diff3() in diff3 * format on @a output_stream, using @a original, @a modified and @a latest * for content changes. * * Use the conflict markers @a conflict_original, @a conflict_modified, * @a conflict_latest and @a conflict_separator or the default one for * each of these if @c NULL is passed. * * @a conflict_style dictates how conflicts are displayed. * * @since New in 1.6. */ svn_error_t * svn_diff_mem_string_output_merge2(svn_stream_t *output_stream, svn_diff_t *diff, const svn_string_t *original, const svn_string_t *modified, const svn_string_t *latest, const char *conflict_original, const char *conflict_modified, const char *conflict_latest, const char *conflict_separator, svn_diff_conflict_display_style_t style, apr_pool_t *pool); /** Similar to svn_diff_mem_string_output_merge2, but with @a * display_original_in_conflict and @a display_resolved_conflicts * booleans instead of the @a conflict_style enum. * * If both booleans are false, acts like * svn_diff_conflict_display_modified_latest; if @a * display_original_in_conflict is true, acts like * svn_diff_conflict_display_modified_original_latest; if @a * display_resolved_conflicts is true, acts like * svn_diff_conflict_display_resolved_modified_latest. The booleans * may not both be true. * * @deprecated Provided for backward compatibility with the 1.5 API. */ SVN_DEPRECATED svn_error_t * svn_diff_mem_string_output_merge(svn_stream_t *output_stream, svn_diff_t *diff, const svn_string_t *original, const svn_string_t *modified, const svn_string_t *latest, const char *conflict_original, const char *conflict_modified, const char *conflict_latest, const char *conflict_separator, svn_boolean_t display_original_in_conflict, svn_boolean_t display_resolved_conflicts, apr_pool_t *pool); /* Diff parsing. If you want to apply a patch to a working copy * rather than parse it, see svn_client_patch(). */ /** * Describes what operation has been performed on a file. * * @since New in 1.7. */ typedef enum svn_diff_operation_kind_e { svn_diff_op_unchanged, svn_diff_op_added, svn_diff_op_deleted, svn_diff_op_copied, svn_diff_op_moved, /* There's no tree changes, just text modifications. */ svn_diff_op_modified } svn_diff_operation_kind_t; /** * A single hunk inside a patch. * * The lines of text comprising the hunk can be interpreted in three ways: * - diff text The hunk as it appears in the unidiff patch file, * including the hunk header line ("@@ ... @@") * - original text The text the patch was based on. * - modified text The result of patching the original text. * * For example, consider a hunk with the following diff text: * * @verbatim @@ -1,5 +1,5 @@ #include <stdio.h> int main(int argc, char *argv[]) { - printf("Hello World!\n"); + printf("I like Subversion!\n"); } @endverbatim * * The original text of this hunk is: * * @verbatim #include <stdio.h> int main(int argc, char *argv[]) { printf("Hello World!\n"); } @endverbatim * * And the modified text is: * * @verbatim #include <stdio.h> int main(int argc, char *argv[]) { printf("I like Subversion!\n"); } @endverbatim * * @see svn_diff_hunk_readline_diff_text() * @see svn_diff_hunk_readline_original_text() * @see svn_diff_hunk_readline_modified_text() * * @since New in 1.7. */ typedef struct svn_diff_hunk_t svn_diff_hunk_t; /** * Allocate @a *stringbuf in @a result_pool, and read into it one line * of the diff text of @a hunk. The first line returned is the hunk header. * Any subsequent lines are unidiff data (starting with '+', '-', or ' '). * If the @a hunk is being interpreted in reverse (i.e. the reverse * parameter of svn_diff_parse_next_patch() was @c TRUE), the diff * text will be returned in reversed form. * The line-terminator is detected automatically and stored in @a *eol * if @a eol is not NULL. * If EOF is reached, set @a *eof to TRUE, and set @a *eol to NULL if the * hunk does not end with a newline character and @a eol is not NULL. * Temporary allocations will be performed in @a scratch_pool. * * @since New in 1.7. */ svn_error_t * svn_diff_hunk_readline_diff_text(svn_diff_hunk_t *hunk, svn_stringbuf_t **stringbuf, const char **eol, svn_boolean_t *eof, apr_pool_t *result_pool, apr_pool_t *scratch_pool); /** * Allocate @a *stringbuf in @a result_pool, and read into it one line * of the original text of @a hunk. * The line-terminator is detected automatically and stored in @a *eol * if @a eol is not NULL. * If EOF is reached, set @a *eof to TRUE, and set @a *eol to NULL if the * hunk text does not end with a newline character and @a eol is not NULL. * Temporary allocations will be performed in @a scratch_pool. * * @see svn_diff_hunk_t * @since New in 1.7. */ svn_error_t * svn_diff_hunk_readline_original_text(svn_diff_hunk_t *hunk, svn_stringbuf_t **stringbuf, const char **eol, svn_boolean_t *eof, apr_pool_t *result_pool, apr_pool_t *scratch_pool); /** * Like svn_diff_hunk_readline_original_text(), but it returns lines from * the modified text of the hunk. * * @see svn_diff_hunk_t * @since New in 1.7. */ svn_error_t * svn_diff_hunk_readline_modified_text(svn_diff_hunk_t *hunk, svn_stringbuf_t **stringbuf, const char **eol, svn_boolean_t *eof, apr_pool_t *result_pool, apr_pool_t *scratch_pool); /** Reset the diff text of @a hunk so it can be read again from the start. * @since New in 1.7. */ void svn_diff_hunk_reset_diff_text(svn_diff_hunk_t *hunk); /** Reset the original text of @a hunk so it can be read again from the start. * @since New in 1.7. */ void svn_diff_hunk_reset_original_text(svn_diff_hunk_t *hunk); /** Reset the modified text of @a hunk so it can be read again from the start. * @since New in 1.7. */ void svn_diff_hunk_reset_modified_text(svn_diff_hunk_t *hunk); /** Return the line offset of the original hunk text, * as parsed from the hunk header. * @since New in 1.7. */ svn_linenum_t svn_diff_hunk_get_original_start(const svn_diff_hunk_t *hunk); /** Return the number of lines in the original @a hunk text, * as parsed from the hunk header. * @since New in 1.7. */ svn_linenum_t svn_diff_hunk_get_original_length(const svn_diff_hunk_t *hunk); /** Return the line offset of the modified @a hunk text, * as parsed from the hunk header. * @since New in 1.7. */ svn_linenum_t svn_diff_hunk_get_modified_start(const svn_diff_hunk_t *hunk); /** Return the number of lines in the modified @a hunk text, * as parsed from the hunk header. * @since New in 1.7. */ svn_linenum_t svn_diff_hunk_get_modified_length(const svn_diff_hunk_t *hunk); /** Return the number of lines of leading context of @a hunk, * i.e. the number of lines starting with ' ' before the first line * that starts with a '+' or '-'. * @since New in 1.7. */ svn_linenum_t svn_diff_hunk_get_leading_context(const svn_diff_hunk_t *hunk); /** Return the number of lines of trailing context of @a hunk, * i.e. the number of lines starting with ' ' after the last line * that starts with a '+' or '-'. * @since New in 1.7. */ svn_linenum_t svn_diff_hunk_get_trailing_context(const svn_diff_hunk_t *hunk); /** * Data type to manage parsing of properties in patches. * API users should not allocate structures of this type directly. * * @since New in 1.7. */ typedef struct svn_prop_patch_t { const char *name; /** Represents the operation performed on the property */ svn_diff_operation_kind_t operation; /** * An array containing an svn_diff_hunk_t object for each hunk parsed * from the patch associated with our property name */ apr_array_header_t *hunks; } svn_prop_patch_t; /** * Data type to manage parsing of patches. * API users should not allocate structures of this type directly. * * @since New in 1.7. */ typedef struct svn_patch_t { /** * The old and new file names as retrieved from the patch file. * These paths are UTF-8 encoded and canonicalized, but otherwise * left unchanged from how they appeared in the patch file. */ const char *old_filename; const char *new_filename; /** * An array containing an svn_diff_hunk_t object for each hunk parsed * from the patch. */ apr_array_header_t *hunks; /** * A hash table keyed by property names containing svn_prop_patch_t * object for each property parsed from the patch. */ apr_hash_t *prop_patches; /** * Represents the operation performed on the file. */ svn_diff_operation_kind_t operation; /** * Indicates whether the patch is being interpreted in reverse. */ svn_boolean_t reverse; } svn_patch_t; /* An opaque type representing an open patch file. * * @since New in 1.7. */ typedef struct svn_patch_file_t svn_patch_file_t; /* Open @a patch_file at @a local_abspath. * Allocate @a patch_file in @a result_pool. * * @since New in 1.7. */ svn_error_t * svn_diff_open_patch_file(svn_patch_file_t **patch_file, const char *local_abspath, apr_pool_t *result_pool); /** * Return the next @a *patch in @a patch_file. * If no patch can be found, set @a *patch to NULL. * If @a reverse is TRUE, invert the patch while parsing it. * If @a ignore_whitespace is TRUE, allow patches with no leading * whitespace to be parsed. * Allocate results in @a result_pool. * Use @a scratch_pool for all other allocations. * * @since New in 1.7. */ svn_error_t * svn_diff_parse_next_patch(svn_patch_t **patch, svn_patch_file_t *patch_file, svn_boolean_t reverse, svn_boolean_t ignore_whitespace, apr_pool_t *result_pool, apr_pool_t *scratch_pool); /** * Dispose of @a patch_file. * Use @a scratch_pool for all temporary allocations. * * @since New in 1.7. */ svn_error_t * svn_diff_close_patch_file(svn_patch_file_t *patch_file, apr_pool_t *scratch_pool); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* SVN_DIFF_H */