Src/CompareOptions.cpp

   1 /**
   2  * @file  CompareOptions.cpp
   3  *
   4  * @brief Compare options implementation.
   5  */
   6
   7 #include "pch.h"
   8 #include "CompareOptions.h"
   9 #include "diff.h"
  10
  11 // Global defined in diffutils code
  12 extern DECL_TLS int recursive;
  13
  14 /**
  15  * @brief Default constructor.
  16  */
  17 CompareOptions::CompareOptions()
  18 : m_ignoreWhitespace(WHITESPACE_COMPARE_ALL)
  19 , m_bIgnoreBlankLines(false)
  20 , m_bIgnoreCase(false)
  21 , m_bIgnoreEOLDifference(false)
  22 {
  23 }
  24
  25 /**
  26  * @brief Copy constructor.
  27  */
  28 CompareOptions::CompareOptions(const CompareOptions & options)
  29 : m_ignoreWhitespace(options.m_ignoreWhitespace)
  30 , m_bIgnoreBlankLines(options.m_bIgnoreBlankLines)
  31 , m_bIgnoreCase(options.m_bIgnoreCase)
  32 , m_bIgnoreEOLDifference(options.m_bIgnoreEOLDifference)
  33 {
  34 }
  35
  36 /**
  37  * @brief Sets options from DiffutilsOptions structure.
  38  * @param [in] options Diffutils options.
  39  */
  40 DiffutilsOptions::DiffutilsOptions(const DiffutilsOptions& options)
  41 : CompareOptions(options)
  42 , m_contextLines(options.m_contextLines)
  43 , m_filterCommentsLines(options.m_filterCommentsLines)
  44 , m_diffAlgorithm(options.m_diffAlgorithm)
  45 , m_bIndentHeuristic(options.m_bIndentHeuristic)
  46 , m_bCompletelyBlankOutIgnoredDiffereneces(options.m_bCompletelyBlankOutIgnoredDiffereneces)
  47 , m_outputStyle(options.m_outputStyle)
  48 {
  49 }
  50
  51 /**
  52  * @brief Sets options from DIFFOPTIONS structure.
  53  * @param [in] options Diffutils options.
  54  */
  55 void CompareOptions::SetFromDiffOptions(const DIFFOPTIONS &options)
  56 {
  57         switch (options.nIgnoreWhitespace)
  58         {
  59         case 0:
  60                 m_ignoreWhitespace = WHITESPACE_COMPARE_ALL;
  61                 break;
  62         case 1:
  63                 m_ignoreWhitespace = WHITESPACE_IGNORE_CHANGE;
  64                 break;
  65         case 2:
  66                 m_ignoreWhitespace = WHITESPACE_IGNORE_ALL;
  67                 break;
  68         default:
  69                 throw "Unknown whitespace ignore value!";
  70                 break;
  71         }
  72         m_bIgnoreBlankLines = options.bIgnoreBlankLines;
  73         m_bIgnoreCase = options.bIgnoreCase;
  74         m_bIgnoreEOLDifference = options.bIgnoreEol;
  75 }
  76
  77 /**
  78  * @brief Default constructor.
  79  */
  80 QuickCompareOptions::QuickCompareOptions()
  81 : m_bStopAfterFirstDiff(false)
  82 {
  83
  84 }
  85
  86 /**
  87  * @brief Default constructor.
  88  */
  89 DiffutilsOptions::DiffutilsOptions()
  90 : m_outputStyle(DIFF_OUTPUT_NORMAL)
  91 , m_contextLines(0)
  92 , m_filterCommentsLines(false)
  93 , m_bCompletelyBlankOutIgnoredDiffereneces(false)
  94 , m_bIndentHeuristic(true)
  95 , m_diffAlgorithm(DIFF_ALGORITHM_DEFAULT)
  96 {
  97 }
  98
  99 /**
 100  * @brief Constructor cloning CompareOptions.
 101  * @param [in] options CompareOptions instance to clone.
 102  */
 103 DiffutilsOptions::DiffutilsOptions(const CompareOptions& options)
 104 : CompareOptions(options)
 105 , m_outputStyle(DIFF_OUTPUT_NORMAL)
 106 , m_contextLines(0)
 107 , m_filterCommentsLines(false)
 108 , m_bCompletelyBlankOutIgnoredDiffereneces(false)
 109 , m_bIndentHeuristic(true)
 110 , m_diffAlgorithm(DIFF_ALGORITHM_DEFAULT)
 111 {
 112 }
 113
 114 /**
 115  * @brief Sets options from DIFFOPTIONS structure.
 116  * @param [in] options Diffutils options.
 117  */
 118 void DiffutilsOptions::SetFromDiffOptions(const DIFFOPTIONS & options)
 119 {
 120         CompareOptions::SetFromDiffOptions(options);
 121         m_bCompletelyBlankOutIgnoredDiffereneces = options.bCompletelyBlankOutIgnoredChanges;
 122         m_filterCommentsLines = options.bFilterCommentsLines;
 123         m_bIndentHeuristic = options.bIndentHeuristic;
 124         switch (options.nDiffAlgorithm)
 125         {
 126         case 0:
 127                 m_diffAlgorithm = DIFF_ALGORITHM_DEFAULT;
 128                 break;
 129         case 1:
 130                 m_diffAlgorithm = DIFF_ALGORITHM_MINIMAL;
 131                 break;
 132         case 2:
 133                 m_diffAlgorithm = DIFF_ALGORITHM_PATIENCE;
 134                 break;
 135         case 3:
 136                 m_diffAlgorithm = DIFF_ALGORITHM_HISTOGRAM;
 137                 break;
 138         default:
 139                 throw "Unknown diff algorithm value!";
 140                 break;
 141         }
 142 }
 143
 144 /**
 145  * @brief Set options to diffutils.
 146  * Diffutils uses options from global variables we must set. Those variables
 147  * aren't most logically named, and most are just int's, with some magic
 148  * values and meanings, with fancy combinations? So not easy to setup. This
 149  * function maps our easier to handle compare options to diffutils globals.
 150  */
 151 void DiffutilsOptions::SetToDiffUtils()
 152 {
 153         switch (m_outputStyle)
 154         {
 155         case DIFF_OUTPUT_NORMAL:
 156                 output_style = OUTPUT_NORMAL;
 157                 break;
 158         case DIFF_OUTPUT_CONTEXT:
 159                 output_style = OUTPUT_CONTEXT;
 160                 break;
 161         case DIFF_OUTPUT_UNIFIED:
 162                 output_style = OUTPUT_UNIFIED;
 163                 break;
 164         case DIFF_OUTPUT_HTML:
 165                 output_style = OUTPUT_HTML;
 166                 break;
 167         default:
 168                 throw "Unknown output style!";
 169                 break;
 170         }
 171
 172         context = m_contextLines;
 173
 174         if (m_ignoreWhitespace == WHITESPACE_IGNORE_CHANGE)
 175                 ignore_space_change_flag = 1;
 176         else
 177                 ignore_space_change_flag = 0;
 178
 179         if (m_ignoreWhitespace == WHITESPACE_IGNORE_ALL)
 180                 ignore_all_space_flag = 1;
 181         else
 182                 ignore_all_space_flag = 0;
 183
 184         if (m_bIgnoreBlankLines)
 185                 ignore_blank_lines_flag = 1;
 186         else
 187                 ignore_blank_lines_flag = 0;
 188
 189         if (m_bIgnoreCase)
 190                 ignore_case_flag = 1;
 191         else
 192                 ignore_case_flag = 0;
 193
 194         if (m_bIgnoreEOLDifference)
 195                 ignore_eol_diff = 1;
 196         else
 197                 ignore_eol_diff = 0;
 198
 199         if (m_ignoreWhitespace != WHITESPACE_COMPARE_ALL || m_bIgnoreCase ||
 200                         m_bIgnoreBlankLines || m_bIgnoreEOLDifference)
 201                 ignore_some_changes = 1;
 202         else
 203                 ignore_some_changes = 0;
 204
 205         if (m_ignoreWhitespace != WHITESPACE_COMPARE_ALL)
 206                 length_varies = 1;
 207         else
 208                 length_varies = 0;
 209
 210         // We have no interest changing these values, hard-code them.
 211         always_text_flag = 0; // diffutils needs to detect binary files
 212         horizon_lines = 0;
 213         heuristic = 1;
 214         recursive = 0;
 215 }
 216
 217 /**
 218  * @brief Gets options to DIFFOPTIONS structure.
 219  * @param [out] options Diffutils options.
 220  */
 221 void DiffutilsOptions::GetAsDiffOptions(DIFFOPTIONS &options) const
 222 {
 223         options.bCompletelyBlankOutIgnoredChanges = m_bCompletelyBlankOutIgnoredDiffereneces;
 224         options.bFilterCommentsLines = m_filterCommentsLines;
 225         options.bIgnoreBlankLines = m_bIgnoreBlankLines;
 226         options.bIgnoreCase = m_bIgnoreCase;
 227         options.bIgnoreEol = m_bIgnoreEOLDifference;
 228
 229         switch (m_ignoreWhitespace)
 230         {
 231         case WHITESPACE_COMPARE_ALL:
 232                 options.nIgnoreWhitespace = 0;
 233                 break;
 234         case WHITESPACE_IGNORE_CHANGE:
 235                 options.nIgnoreWhitespace = 1;
 236                 break;
 237         case WHITESPACE_IGNORE_ALL:
 238                 options.nIgnoreWhitespace = 2;
 239                 break;
 240         default:
 241                 throw "Unknown whitespace ignore value!";
 242                 break;
 243         }
 244 }
 245
 246 QuickCompareOptions::QuickCompareOptions(const CompareOptions& options)
 247 : CompareOptions(options)
 248 , m_bStopAfterFirstDiff(false)
 249 {
 250 }