src/third_party/codesighs/maptsvdifftool.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is maptsvdifftool.c code, released
  17  * Oct 3, 2002.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Netscape Communications Corporation.
  21  * Portions created by the Initial Developer are Copyright (C) 2002
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *   Garrett Arch Blythe, 03-October-2002
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <time.h>
  45 #include <ctype.h>
  46
  47 #define ERROR_REPORT(num, val, msg)   fprintf(stderr, "error(%d):\t\"%s\"\t%s\n", (num), (val), (msg));
  48 #define CLEANUP(ptr)    do { if(NULL != ptr) { free(ptr); ptr = NULL; } } while(0)
  49
  50
  51 typedef struct __struct_Options
  52 /*
  53 **  Options to control how we perform.
  54 **
  55 **  mProgramName    Used in help text.
  56 **  mInput          File to read for input.
  57 **                  Default is stdin.
  58 **  mInputName      Name of the file.
  59 **  mOutput         Output file, append.
  60 **                  Default is stdout.
  61 **  mOutputName     Name of the file.
  62 **  mHelp           Whether or not help should be shown.
  63 **  mSummaryOnly    Only output a signle line.
  64 **  mZeroDrift      Output zero drift data.
  65 **  mNegation       Perform negation heuristics on the symbol drifts.
  66 */
  67 {
  68     const char* mProgramName;
  69     FILE* mInput;
  70     char* mInputName;
  71     FILE* mOutput;
  72     char* mOutputName;
  73     int mHelp;
  74     int mSummaryOnly;
  75     int mZeroDrift;
  76     int mNegation;
  77 }
  78 Options;
  79
  80
  81 typedef struct __struct_Switch
  82 /*
  83 **  Command line options.
  84 */
  85 {
  86     const char* mLongName;
  87     const char* mShortName;
  88     int mHasValue;
  89     const char* mValue;
  90     const char* mDescription;
  91 }
  92 Switch;
  93
  94 #define DESC_NEWLINE "\n\t\t"
  95
  96 static Switch gInputSwitch = {"--input", "-i", 1, NULL, "Specify input file." DESC_NEWLINE "stdin is default."};
  97 static Switch gOutputSwitch = {"--output", "-o", 1, NULL, "Specify output file." DESC_NEWLINE "Appends if file exists." DESC_NEWLINE "stdout is default."};
  98 static Switch gSummarySwitch = {"--summary", "-s", 0, NULL, "Only output a single line." DESC_NEWLINE "The cumulative size changes." DESC_NEWLINE "Overrides all other output options."};
  99 static Switch gZeroDriftSwitch = {"--zerodrift", "-z", 0, NULL, "Output zero drift data." DESC_NEWLINE "Reports symbol changes even when there is no net drift."};
 100 static Switch gNegationSwitch = {"--negation", "-n", 0, NULL, "Use negation heuristics." DESC_NEWLINE "When symbol sizes are inferred by offset, order changes cause noise." DESC_NEWLINE "This helps see through the noise by eliminating equal and opposite drifts."};
 101 static Switch gHelpSwitch = {"--help", "-h", 0, NULL, "Information on usage."};
 102
 103 static Switch* gSwitches[] = {
 104         &gInputSwitch,
 105         &gOutputSwitch,
 106         &gSummarySwitch,
 107         &gZeroDriftSwitch,
 108         &gNegationSwitch,
 109         &gHelpSwitch
 110 };
 111
 112
 113 typedef struct __struct_SizeComposition
 114 /*
 115 **  Used to keep which parts positive and negative resulted in the total.
 116 */
 117 {
 118     int mPositive;
 119     int mNegative;
 120 }
 121 SizeComposition;
 122
 123
 124 typedef struct __struct_SizeStats
 125 /*
 126 **  Keep track of sizes.
 127 **  Use signed integers so that negatives are valid, in which case we shrunk.
 128 */
 129 {
 130     int mCode;
 131     SizeComposition mCodeComposition;
 132
 133     int mData;
 134     SizeComposition mDataComposition;
 135 }
 136 SizeStats;
 137
 138
 139 typedef enum __enum_SegmentClass
 140 /*
 141 **  What type of data a segment holds.
 142 */
 143 {
 144         CODE,
 145         DATA
 146 }
 147 SegmentClass;
 148
 149
 150 typedef struct __struct_SymbolStats
 151 /*
 152 **  Symbol level stats.
 153 */
 154 {
 155     char* mSymbol;
 156     int mSize;
 157 }
 158 SymbolStats;
 159
 160
 161 typedef struct __struct_ObjectStats
 162 /*
 163 **  Object level stats.
 164 */
 165 {
 166     char* mObject;
 167     int mSize;
 168     SizeComposition mComposition;
 169     SymbolStats* mSymbols;
 170     unsigned mSymbolCount;
 171 }
 172 ObjectStats;
 173
 174
 175 typedef struct __struct_SegmentStats
 176 /*
 177 **  Segment level stats.
 178 */
 179 {
 180     char* mSegment;
 181     SegmentClass mClass;
 182     int mSize;
 183     SizeComposition mComposition;
 184     ObjectStats* mObjects;
 185     unsigned mObjectCount;
 186 }
 187 SegmentStats;
 188
 189
 190 typedef struct __struct_ModuleStats
 191 /*
 192 **  Module level stats.
 193 */
 194 {
 195     char* mModule;
 196     SizeStats mSize;
 197     SegmentStats* mSegments;
 198     unsigned mSegmentCount;
 199 }
 200 ModuleStats;
 201
 202
 203 static int moduleCompare(const void* in1, const void* in2)
 204 /*
 205 **  qsort helper.
 206 */
 207 {
 208     int retval = 0;
 209
 210     ModuleStats* one = (ModuleStats*)in1;
 211     ModuleStats* two = (ModuleStats*)in2;
 212
 213     int oneSize = (one->mSize.mCode + one->mSize.mData);
 214     int twoSize = (two->mSize.mCode + two->mSize.mData);
 215
 216     if(oneSize < twoSize)
 217     {
 218         retval = 1;
 219     }
 220     else if(oneSize > twoSize)
 221     {
 222         retval = -1;
 223     }
 224     else
 225     {
 226         retval = strcmp(one->mModule, two->mModule);
 227         if(0 > oneSize && 0 > twoSize)
 228         {
 229             retval *= -1;
 230         }
 231     }
 232
 233     return retval;
 234 }
 235
 236
 237 static int segmentCompare(const void* in1, const void* in2)
 238 /*
 239 **  qsort helper.
 240 */
 241 {
 242     int retval = 0;
 243
 244     SegmentStats* one = (SegmentStats*)in1;
 245     SegmentStats* two = (SegmentStats*)in2;
 246
 247     if(one->mSize < two->mSize)
 248     {
 249         retval = 1;
 250     }
 251     else if(one->mSize > two->mSize)
 252     {
 253         retval = -1;
 254     }
 255     else
 256     {
 257         retval = strcmp(one->mSegment, two->mSegment);
 258         if(0 > one->mSize && 0 > two->mSize)
 259         {
 260             retval *= -1;
 261         }
 262     }
 263
 264     return retval;
 265 }
 266
 267
 268 static int objectCompare(const void* in1, const void* in2)
 269 /*
 270 **  qsort helper.
 271 */
 272 {
 273     int retval = 0;
 274
 275     ObjectStats* one = (ObjectStats*)in1;
 276     ObjectStats* two = (ObjectStats*)in2;
 277
 278     if(one->mSize < two->mSize)
 279     {
 280         retval = 1;
 281     }
 282     else if(one->mSize > two->mSize)
 283     {
 284         retval = -1;
 285     }
 286     else
 287     {
 288         retval = strcmp(one->mObject, two->mObject);
 289         if(0 > one->mSize && 0 > two->mSize)
 290         {
 291             retval *= -1;
 292         }
 293     }
 294
 295     return retval;
 296 }
 297
 298
 299 static int symbolCompare(const void* in1, const void* in2)
 300 /*
 301 **  qsort helper.
 302 */
 303 {
 304     int retval = 0;
 305
 306     SymbolStats* one = (SymbolStats*)in1;
 307     SymbolStats* two = (SymbolStats*)in2;
 308
 309     if(one->mSize < two->mSize)
 310     {
 311         retval = 1;
 312     }
 313     else if(one->mSize > two->mSize)
 314     {
 315         retval = -1;
 316     }
 317     else
 318     {
 319         retval = strcmp(one->mSymbol, two->mSymbol);
 320         if(0 > one->mSize && 0 > two->mSize)
 321         {
 322             retval *= -1;
 323         }
 324     }
 325
 326     return retval;
 327 }
 328
 329
 330 void trimWhite(char* inString)
 331 /*
 332 **  Remove any whitespace from the end of the string.
 333 */
 334 {
 335     int len = strlen(inString);
 336
 337     while(len)
 338     {
 339         len--;
 340
 341         if(isspace(*(inString + len)))
 342         {
 343             *(inString + len) = '\0';
 344         }
 345         else
 346         {
 347             break;
 348         }
 349     }
 350 }
 351
 352
 353 int difftool(Options* inOptions)
 354 /*
 355 **  Read a diff file and spit out relevant information.
 356 */
 357 {
 358     int retval = 0;
 359     char lineBuffer[0x500];
 360     SizeStats overall;
 361     ModuleStats* modules = NULL;
 362     unsigned moduleCount = 0;
 363     unsigned moduleLoop = 0;
 364     ModuleStats* theModule = NULL;
 365     unsigned segmentLoop = 0;
 366     SegmentStats* theSegment = NULL;
 367     unsigned objectLoop = 0;
 368     ObjectStats* theObject = NULL;
 369     unsigned symbolLoop = 0;
 370     SymbolStats* theSymbol = NULL;
 371     unsigned allSymbolCount = 0;
 372
 373     memset(&overall, 0, sizeof(overall));
 374
 375     /*
 376     **  Read the entire diff file.
 377     **  We're only interested in lines beginning with < or >
 378     */
 379     while(0 == retval && NULL != fgets(lineBuffer, sizeof(lineBuffer), inOptions->mInput))
 380     {
 381         trimWhite(lineBuffer);
 382
 383         if(('<' == lineBuffer[0] || '>' == lineBuffer[0]) && ' ' == lineBuffer[1])
 384         {
 385             int additive = 0;
 386             char* theLine = &lineBuffer[2];
 387             int scanRes = 0;
 388             int size;
 389             char segClass[0x10];
 390             char scope[0x10];
 391             char module[0x100];
 392             char segment[0x40];
 393             char object[0x100];
 394             char* symbol = NULL;
 395
 396             /*
 397             **  Figure out if the line adds or subtracts from something.
 398             */
 399             if('>' == lineBuffer[0])
 400             {
 401                 additive = __LINE__;
 402             }
 403
 404
 405             /*
 406             **  Scan the line for information.
 407             */
 408             scanRes = sscanf(theLine,
 409                 "%x\t%s\t%s\t%s\t%s\t%s\t",
 410                 (unsigned*)&size,
 411                 segClass,
 412                 scope,
 413                 module,
 414                 segment,
 415                 object);
 416
 417             if(6 == scanRes)
 418             {
 419                 SegmentClass segmentClass = DATA;
 420
 421                 symbol = strrchr(theLine, '\t') + 1;
 422
 423                 if(0 == strcmp(segClass, "CODE"))
 424                 {
 425                     segmentClass = CODE;
 426                 }
 427                 else if(0 == strcmp(segClass, "DATA"))
 428                 {
 429                     segmentClass = DATA;
 430                 }
 431                 else
 432                 {
 433                     retval = __LINE__;
 434                     ERROR_REPORT(retval, segClass, "Unable to determine segment class.");
 435                 }
 436
 437                 if(0 == retval)
 438                 {
 439                     unsigned moduleIndex = 0;
 440
 441                     /*
 442                     **  Find, in succession, the following things:
 443                     **      the module
 444                     **      the segment
 445                     **      the object
 446                     **      the symbol
 447                     **  Failure to find any one of these means to create it.
 448                     */
 449
 450                     for(moduleIndex = 0; moduleIndex < moduleCount; moduleIndex++)
 451                     {
 452                         if(0 == strcmp(modules[moduleIndex].mModule, module))
 453                         {
 454                             break;
 455                         }
 456                     }
 457
 458                     if(moduleIndex == moduleCount)
 459                     {
 460                         void* moved = NULL;
 461
 462                         moved = realloc(modules, sizeof(ModuleStats) * (1 + moduleCount));
 463                         if(NULL != moved)
 464                         {
 465                             modules = (ModuleStats*)moved;
 466                             moduleCount++;
 467                             memset(modules + moduleIndex, 0, sizeof(ModuleStats));
 468
 469                             modules[moduleIndex].mModule = strdup(module);
 470                             if(NULL == modules[moduleIndex].mModule)
 471                             {
 472                                 retval = __LINE__;
 473                                 ERROR_REPORT(retval, module, "Unable to duplicate string.");
 474                             }
 475                         }
 476                         else
 477                         {
 478                             retval = __LINE__;
 479                             ERROR_REPORT(retval, inOptions->mProgramName, "Unable to increase module array.");
 480                         }
 481                     }
 482
 483                     if(0 == retval)
 484                     {
 485                         unsigned segmentIndex = 0;
 486                         theModule = (modules + moduleIndex);
 487
 488                         for(segmentIndex = 0; segmentIndex < theModule->mSegmentCount; segmentIndex++)
 489                         {
 490                             if(0 == strcmp(segment, theModule->mSegments[segmentIndex].mSegment))
 491                             {
 492                                 break;
 493                             }
 494                         }
 495
 496                         if(segmentIndex == theModule->mSegmentCount)
 497                         {
 498                             void* moved = NULL;
 499
 500                             moved = realloc(theModule->mSegments, sizeof(SegmentStats) * (theModule->mSegmentCount + 1));
 501                             if(NULL != moved)
 502                             {
 503                                 theModule->mSegments = (SegmentStats*)moved;
 504                                 theModule->mSegmentCount++;
 505                                 memset(theModule->mSegments + segmentIndex, 0, sizeof(SegmentStats));
 506
 507                                 theModule->mSegments[segmentIndex].mClass = segmentClass;
 508                                 theModule->mSegments[segmentIndex].mSegment = strdup(segment);
 509                                 if(NULL == theModule->mSegments[segmentIndex].mSegment)
 510                                 {
 511                                     retval = __LINE__;
 512                                     ERROR_REPORT(retval, segment, "Unable to duplicate string.");
 513                                 }
 514                             }
 515                             else
 516                             {
 517                                 retval = __LINE__;
 518                                 ERROR_REPORT(retval, inOptions->mProgramName, "Unable to increase segment array.");
 519                             }
 520                         }
 521
 522                         if(0 == retval)
 523                         {
 524                             unsigned objectIndex = 0;
 525                             theSegment = (theModule->mSegments + segmentIndex);
 526
 527                             for(objectIndex = 0; objectIndex < theSegment->mObjectCount; objectIndex++)
 528                             {
 529                                 if(0 == strcmp(object, theSegment->mObjects[objectIndex].mObject))
 530                                 {
 531                                     break;
 532                                 }
 533                             }
 534
 535                             if(objectIndex == theSegment->mObjectCount)
 536                             {
 537                                 void* moved = NULL;
 538
 539                                 moved = realloc(theSegment->mObjects, sizeof(ObjectStats) * (1 + theSegment->mObjectCount));
 540                                 if(NULL != moved)
 541                                 {
 542                                     theSegment->mObjects = (ObjectStats*)moved;
 543                                     theSegment->mObjectCount++;
 544                                     memset(theSegment->mObjects + objectIndex, 0, sizeof(ObjectStats));
 545
 546                                     theSegment->mObjects[objectIndex].mObject = strdup(object);
 547                                     if(NULL == theSegment->mObjects[objectIndex].mObject)
 548                                     {
 549                                         retval = __LINE__;
 550                                         ERROR_REPORT(retval, object, "Unable to duplicate string.");
 551                                     }
 552                                 }
 553                                 else
 554                                 {
 555                                     retval = __LINE__;
 556                                     ERROR_REPORT(retval, inOptions->mProgramName, "Unable to increase object array.");
 557                                 }
 558                             }
 559
 560                             if(0 == retval)
 561                             {
 562                                 unsigned symbolIndex = 0;
 563                                 theObject = (theSegment->mObjects + objectIndex);
 564
 565                                 for(symbolIndex = 0; symbolIndex < theObject->mSymbolCount; symbolIndex++)
 566                                 {
 567                                     if(0 == strcmp(symbol, theObject->mSymbols[symbolIndex].mSymbol))
 568                                     {
 569                                         break;
 570                                     }
 571                                 }
 572
 573                                 if(symbolIndex == theObject->mSymbolCount)
 574                                 {
 575                                     void* moved = NULL;
 576
 577                                     moved = realloc(theObject->mSymbols, sizeof(SymbolStats) * (1 + theObject->mSymbolCount));
 578                                     if(NULL != moved)
 579                                     {
 580                                         theObject->mSymbols = (SymbolStats*)moved;
 581                                         theObject->mSymbolCount++;
 582                                         allSymbolCount++;
 583                                         memset(theObject->mSymbols + symbolIndex, 0, sizeof(SymbolStats));
 584
 585                                         theObject->mSymbols[symbolIndex].mSymbol = strdup(symbol);
 586                                         if(NULL == theObject->mSymbols[symbolIndex].mSymbol)
 587                                         {
 588                                             retval = __LINE__;
 589                                             ERROR_REPORT(retval, symbol, "Unable to duplicate string.");
 590                                         }
 591                                     }
 592                                     else
 593                                     {
 594                                         retval = __LINE__;
 595                                         ERROR_REPORT(retval, inOptions->mProgramName, "Unable to increase symbol array.");
 596                                     }
 597                                 }
 598
 599                                 if(0 == retval)
 600                                 {
 601                                     theSymbol = (theObject->mSymbols + symbolIndex);
 602
 603                                     /*
 604                                     **  Update our various totals.
 605                                     */
 606                                     if(additive)
 607                                     {
 608                                         if(CODE == segmentClass)
 609                                         {
 610                                             overall.mCode += size;
 611                                             theModule->mSize.mCode += size;
 612                                         }
 613                                         else if(DATA == segmentClass)
 614                                         {
 615                                             overall.mData += size;
 616                                             theModule->mSize.mData += size;
 617                                         }
 618
 619                                         theSegment->mSize += size;
 620                                         theObject->mSize += size;
 621                                         theSymbol->mSize += size;
 622                                     }
 623                                     else
 624                                     {
 625                                         if(CODE == segmentClass)
 626                                         {
 627                                             overall.mCode -= size;
 628                                             theModule->mSize.mCode -= size;
 629                                         }
 630                                         else if(DATA == segmentClass)
 631                                         {
 632                                             overall.mData -= size;
 633                                             theModule->mSize.mData -= size;
 634                                         }
 635
 636                                         theSegment->mSize -= size;
 637                                         theObject->mSize -= size;
 638                                         theSymbol->mSize -= size;
 639                                     }
 640                                 }
 641                             }
 642                         }
 643                     }
 644                 }
 645             }
 646             else
 647             {
 648                 retval = __LINE__;
 649                 ERROR_REPORT(retval, inOptions->mInputName, "Unable to scan line data.");
 650             }
 651         }
 652     }
 653
 654     if(0 == retval && 0 != ferror(inOptions->mInput))
 655     {
 656         retval = __LINE__;
 657         ERROR_REPORT(retval, inOptions->mInputName, "Unable to read file.");
 658     }
 659
 660     /*
 661     **  Next, it is time to perform revisionist history of sorts.
 662     **  If the negation switch is in play, we perfrom the following
 663     **      aggressive steps:
 664     **
 665     **  For each section, find size changes which have an equal and
 666     **      opposite change, and set them both to zero.
 667     **  However, you can only do this if the number of negating changes
 668     **      is even, as if it is odd, then any one of the many could be
 669     **      at fault for the actual change.
 670     **
 671     **  This orginally exists to make the win32 codesighs reports more
 672     **      readable/meaningful.
 673     */
 674     if(0 == retval && 0 != inOptions->mNegation)
 675     {
 676         ObjectStats** objArray = NULL;
 677         SymbolStats** symArray = NULL;
 678
 679         /*
 680         **  Create arrays big enough to hold all symbols.
 681         **  As well as an array to keep the owning object at the same index.
 682         **  We will keep the object around as we may need to modify the size.
 683         */
 684         objArray = (ObjectStats**)malloc(allSymbolCount * sizeof(ObjectStats*));
 685         symArray = (SymbolStats**)malloc(allSymbolCount * sizeof(SymbolStats*));
 686         if(NULL == objArray || NULL == symArray)
 687         {
 688             retval = __LINE__;
 689             ERROR_REPORT(retval, inOptions->mProgramName, "Unable to allocate negation array memory.");
 690         }
 691         else
 692         {
 693             unsigned arrayCount = 0;
 694             unsigned arrayLoop = 0;
 695
 696             /*
 697             **  Go through and perform the steps on each section/segment.
 698             */
 699             for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++)
 700             {
 701                 theModule = modules + moduleLoop;
 702
 703                 for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++)
 704                 {
 705                     theSegment = theModule->mSegments + segmentLoop;
 706
 707                     /*
 708                     **  Collect all symbols under this section.
 709                     **  The symbols are spread out between all the objects,
 710                     **      so keep track of both independently at the
 711                     **      same index.
 712                     */
 713                     arrayCount = 0;
 714
 715                     for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++)
 716                     {
 717                         theObject = theSegment->mObjects + objectLoop;
 718
 719                         for(symbolLoop = 0; symbolLoop < theObject->mSymbolCount; symbolLoop++)
 720                         {
 721                             theSymbol = theObject->mSymbols + symbolLoop;
 722
 723                             objArray[arrayCount] = theObject;
 724                             symArray[arrayCount] = theSymbol;
 725                             arrayCount++;
 726                         }
 727                     }
 728
 729                     /*
 730                     **  Now that we have a list of symbols, go through each
 731                     **      and see if there is a chance of negation.
 732                     */
 733                     for(arrayLoop = 0; arrayLoop < arrayCount; arrayLoop++)
 734                     {
 735                         /*
 736                         **  If the item is NULL, it was already negated.
 737                         **  Don't do this for items with a zero size.
 738                         */
 739                         if(NULL != symArray[arrayLoop] && 0 != symArray[arrayLoop]->mSize)
 740                         {
 741                             unsigned identicalValues = 0;
 742                             unsigned oppositeValues = 0;
 743                             unsigned lookLoop = 0;
 744                             const int lookingFor = symArray[arrayLoop]->mSize;
 745
 746                             /*
 747                             **  Count the number of items with this value.
 748                             **  Count the number of items with the opposite equal value.
 749                             **  If they are equal, go through and negate all sizes.
 750                             */
 751                             for(lookLoop = arrayLoop; lookLoop < arrayCount; lookLoop++)
 752                             {
 753                                 /*
 754                                 **  Skip negated items.
 755                                 **  Skip zero length items.
 756                                 */
 757                                 if(NULL == symArray[lookLoop] || 0 == symArray[lookLoop]->mSize)
 758                                 {
 759                                     continue;
 760                                 }
 761
 762                                 if(lookingFor == symArray[lookLoop]->mSize)
 763                                 {
 764                                     identicalValues++;
 765                                 }
 766                                 else if((-1 * lookingFor) == symArray[lookLoop]->mSize)
 767                                 {
 768                                     oppositeValues++;
 769                                 }
 770                             }
 771
 772                             if(0 != identicalValues && identicalValues == oppositeValues)
 773                             {
 774                                 unsigned negationLoop = 0;
 775
 776                                 for(negationLoop = arrayLoop; 0 != identicalValues || 0 != oppositeValues; negationLoop++)
 777                                 {
 778                                     /*
 779                                     **  Skip negated items.
 780                                     **  Skip zero length items.
 781                                     */
 782                                     if(NULL == symArray[negationLoop] || 0 == symArray[negationLoop]->mSize)
 783                                     {
 784                                         continue;
 785                                     }
 786
 787                                     /*
 788                                     **  Negate any size matches.
 789                                     **  Reflect the change in the object as well.
 790                                     **  Clear the symbol.
 791                                     */
 792                                     if(lookingFor == symArray[negationLoop]->mSize)
 793                                     {
 794                                         objArray[negationLoop]->mSize -= lookingFor;
 795                                         symArray[negationLoop]->mSize = 0;
 796                                         symArray[negationLoop] = NULL;
 797
 798                                         identicalValues--;
 799                                     }
 800                                     else if((-1 * lookingFor) == symArray[negationLoop]->mSize)
 801                                     {
 802                                         objArray[negationLoop]->mSize += lookingFor;
 803                                         symArray[negationLoop]->mSize = 0;
 804                                         symArray[negationLoop] = NULL;
 805
 806                                         oppositeValues--;
 807                                     }
 808                                 }
 809                             }
 810                         }
 811                     }
 812                 }
 813             }
 814         }
 815
 816         CLEANUP(objArray);
 817         CLEANUP(symArray);
 818     }
 819
 820
 821     /*
 822     **  If all went well, time to report.
 823     */
 824     if(0 == retval)
 825     {
 826         /*
 827         **  Loop through our data once more, so that the symbols can
 828         **      propigate their changes upwards in a positive/negative
 829         **      fashion.
 830         **  This will help give the composite change more meaning.
 831         */
 832         for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++)
 833         {
 834             theModule = modules + moduleLoop;
 835
 836             /*
 837             **  Skip if there is zero drift, or no net change.
 838             */
 839             if(0 == inOptions->mZeroDrift && 0 == (theModule->mSize.mCode + theModule->mSize.mData))
 840             {
 841                 continue;
 842             }
 843
 844             for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++)
 845             {
 846                 theSegment = theModule->mSegments + segmentLoop;
 847
 848                 /*
 849                 **  Skip if there is zero drift, or no net change.
 850                 */
 851                 if(0 == inOptions->mZeroDrift && 0 == theSegment->mSize)
 852                 {
 853                     continue;
 854                 }
 855
 856                 for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++)
 857                 {
 858                     theObject = theSegment->mObjects + objectLoop;
 859
 860                     /*
 861                     **  Skip if there is zero drift, or no net change.
 862                     */
 863                     if(0 == inOptions->mZeroDrift && 0 == theObject->mSize)
 864                     {
 865                         continue;
 866                     }
 867
 868                     for(symbolLoop = 0; symbolLoop < theObject->mSymbolCount; symbolLoop++)
 869                     {
 870                         theSymbol = theObject->mSymbols + symbolLoop;
 871
 872                         /*
 873                         **  Propagate the composition all the way to the top.
 874                         **  Sizes of zero change are skipped.
 875                         */
 876                         if(0 < theSymbol->mSize)
 877                         {
 878                             theObject->mComposition.mPositive += theSymbol->mSize;
 879                             theSegment->mComposition.mPositive += theSymbol->mSize;
 880                             if(CODE == theSegment->mClass)
 881                             {
 882                                 overall.mCodeComposition.mPositive += theSymbol->mSize;
 883                                 theModule->mSize.mCodeComposition.mPositive += theSymbol->mSize;
 884                             }
 885                             else if(DATA == theSegment->mClass)
 886                             {
 887                                 overall.mDataComposition.mPositive += theSymbol->mSize;
 888                                 theModule->mSize.mDataComposition.mPositive += theSymbol->mSize;
 889                             }
 890                         }
 891                         else if(0 > theSymbol->mSize)
 892                         {
 893                             theObject->mComposition.mNegative += theSymbol->mSize;
 894                             theSegment->mComposition.mNegative += theSymbol->mSize;
 895                             if(CODE == theSegment->mClass)
 896                             {
 897                                 overall.mCodeComposition.mNegative += theSymbol->mSize;
 898                                 theModule->mSize.mCodeComposition.mNegative += theSymbol->mSize;
 899                             }
 900                             else if(DATA == theSegment->mClass)
 901                             {
 902                                 overall.mDataComposition.mNegative += theSymbol->mSize;
 903                                 theModule->mSize.mDataComposition.mNegative += theSymbol->mSize;
 904                             }
 905                         }
 906                     }
 907                 }
 908             }
 909         }
 910
 911
 912         if(inOptions->mSummaryOnly)
 913         {
 914             fprintf(inOptions->mOutput, "%+d (%+d/%+d)\n", overall.mCode + overall.mData, overall.mCodeComposition.mPositive + overall.mDataComposition.mPositive, overall.mCodeComposition.mNegative + overall.mDataComposition.mNegative);
 915         }
 916         else
 917         {
 918             fprintf(inOptions->mOutput, "Overall Change in Size\n");
 919             fprintf(inOptions->mOutput, "\tTotal:\t%+11d (%+d/%+d)\n", overall.mCode + overall.mData, overall.mCodeComposition.mPositive + overall.mDataComposition.mPositive, overall.mCodeComposition.mNegative + overall.mDataComposition.mNegative);
 920             fprintf(inOptions->mOutput, "\tCode:\t%+11d (%+d/%+d)\n", overall.mCode, overall.mCodeComposition.mPositive, overall.mCodeComposition.mNegative);
 921             fprintf(inOptions->mOutput, "\tData:\t%+11d (%+d/%+d)\n", overall.mData, overall.mDataComposition.mPositive, overall.mDataComposition.mNegative);
 922         }
 923
 924         /*
 925         **  Check what else we should output.
 926         */
 927         if(0 == inOptions->mSummaryOnly && NULL != modules && moduleCount)
 928         {
 929             const char* segmentType = NULL;
 930
 931             /*
 932             **  We're going to sort everything.
 933             */
 934             qsort(modules, moduleCount, sizeof(ModuleStats), moduleCompare);
 935             for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++)
 936             {
 937                 theModule = modules + moduleLoop;
 938
 939                 qsort(theModule->mSegments, theModule->mSegmentCount, sizeof(SegmentStats), segmentCompare);
 940
 941                 for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++)
 942                 {
 943                     theSegment = theModule->mSegments + segmentLoop;
 944
 945                     qsort(theSegment->mObjects, theSegment->mObjectCount, sizeof(ObjectStats), objectCompare);
 946
 947                     for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++)
 948                     {
 949                         theObject = theSegment->mObjects + objectLoop;
 950
 951                         qsort(theObject->mSymbols, theObject->mSymbolCount, sizeof(SymbolStats), symbolCompare);
 952                     }
 953                 }
 954             }
 955
 956             /*
 957             **  Loop through for output.
 958             */
 959             for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++)
 960             {
 961                 theModule = modules + moduleLoop;
 962
 963                 /*
 964                 **  Skip if there is zero drift, or no net change.
 965                 */
 966                 if(0 == inOptions->mZeroDrift && 0 == (theModule->mSize.mCode + theModule->mSize.mData))
 967                 {
 968                     continue;
 969                 }
 970
 971                 fprintf(inOptions->mOutput, "\n");
 972                 fprintf(inOptions->mOutput, "%s\n", theModule->mModule);
 973                 fprintf(inOptions->mOutput, "\tTotal:\t%+11d (%+d/%+d)\n", theModule->mSize.mCode + theModule->mSize.mData, theModule->mSize.mCodeComposition.mPositive + theModule->mSize.mDataComposition.mPositive, theModule->mSize.mCodeComposition.mNegative + theModule->mSize.mDataComposition.mNegative);
 974                 fprintf(inOptions->mOutput, "\tCode:\t%+11d (%+d/%+d)\n", theModule->mSize.mCode, theModule->mSize.mCodeComposition.mPositive, theModule->mSize.mCodeComposition.mNegative);
 975                 fprintf(inOptions->mOutput, "\tData:\t%+11d (%+d/%+d)\n", theModule->mSize.mData, theModule->mSize.mDataComposition.mPositive, theModule->mSize.mDataComposition.mNegative);
 976
 977                 for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++)
 978                 {
 979                     theSegment = theModule->mSegments + segmentLoop;
 980
 981                     /*
 982                     **  Skip if there is zero drift, or no net change.
 983                     */
 984                     if(0 == inOptions->mZeroDrift && 0 == theSegment->mSize)
 985                     {
 986                         continue;
 987                     }
 988
 989                     if(CODE == theSegment->mClass)
 990                     {
 991                         segmentType = "CODE";
 992                     }
 993                     else if(DATA == theSegment->mClass)
 994                     {
 995                         segmentType = "DATA";
 996                     }
 997
 998                     fprintf(inOptions->mOutput, "\t%+11d (%+d/%+d)\t%s (%s)\n", theSegment->mSize, theSegment->mComposition.mPositive, theSegment->mComposition.mNegative, theSegment->mSegment, segmentType);
 999
1000                     for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++)
1001                     {
1002                         theObject = theSegment->mObjects + objectLoop;
1003
1004                         /*
1005                         **  Skip if there is zero drift, or no net change.
1006                         */
1007                         if(0 == inOptions->mZeroDrift && 0 == theObject->mSize)
1008                         {
1009                             continue;
1010                         }
1011
1012                         fprintf(inOptions->mOutput, "\t\t%+11d (%+d/%+d)\t%s\n", theObject->mSize, theObject->mComposition.mPositive, theObject->mComposition.mNegative, theObject->mObject);
1013
1014                         for(symbolLoop = 0; symbolLoop < theObject->mSymbolCount; symbolLoop++)
1015                         {
1016                             theSymbol = theObject->mSymbols + symbolLoop;
1017
1018                             /*
1019                             **  Skip if there is zero drift, or no net change.
1020                             */
1021                             if(0 == inOptions->mZeroDrift && 0 == theSymbol->mSize)
1022                             {
1023                                 continue;
1024                             }
1025
1026                             fprintf(inOptions->mOutput, "\t\t\t%+11d\t%s\n", theSymbol->mSize, theSymbol->mSymbol);
1027                         }
1028                     }
1029                 }
1030             }
1031         }
1032     }
1033
1034     /*
1035     **  Cleanup time.
1036     */
1037     for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++)
1038     {
1039         theModule = modules + moduleLoop;
1040
1041         for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++)
1042         {
1043             theSegment = theModule->mSegments + segmentLoop;
1044
1045             for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++)
1046             {
1047                 theObject = theSegment->mObjects + objectLoop;
1048
1049                 for(symbolLoop = 0; symbolLoop < theObject->mSymbolCount; symbolLoop++)
1050                 {
1051                     theSymbol = theObject->mSymbols + symbolLoop;
1052
1053                     CLEANUP(theSymbol->mSymbol);
1054                 }
1055
1056                 CLEANUP(theObject->mSymbols);
1057                 CLEANUP(theObject->mObject);
1058             }
1059
1060             CLEANUP(theSegment->mObjects);
1061             CLEANUP(theSegment->mSegment);
1062         }
1063
1064         CLEANUP(theModule->mSegments);
1065         CLEANUP(theModule->mModule);
1066     }
1067     CLEANUP(modules);
1068
1069     return retval;
1070 }
1071
1072
1073 int initOptions(Options* outOptions, int inArgc, char** inArgv)
1074 /*
1075 **  returns int     0 if successful.
1076 */
1077 {
1078     int retval = 0;
1079     int loop = 0;
1080     int switchLoop = 0;
1081     int match = 0;
1082     const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]);
1083     Switch* current = NULL;
1084
1085     /*
1086     **  Set any defaults.
1087     */
1088     memset(outOptions, 0, sizeof(Options));
1089     outOptions->mProgramName = inArgv[0];
1090     outOptions->mInput = stdin;
1091     outOptions->mInputName = strdup("stdin");
1092     outOptions->mOutput = stdout;
1093     outOptions->mOutputName = strdup("stdout");
1094
1095     if(NULL == outOptions->mOutputName || NULL == outOptions->mInputName)
1096     {
1097         retval = __LINE__;
1098         ERROR_REPORT(retval, "stdin/stdout", "Unable to strdup.");
1099     }
1100
1101     /*
1102     **  Go through and attempt to do the right thing.
1103     */
1104     for(loop = 1; loop < inArgc && 0 == retval; loop++)
1105     {
1106         match = 0;
1107         current = NULL;
1108
1109         for(switchLoop = 0; switchLoop < switchCount && 0 == retval; switchLoop++)
1110         {
1111             if(0 == strcmp(gSwitches[switchLoop]->mLongName, inArgv[loop]))
1112             {
1113                 match = __LINE__;
1114             }
1115             else if(0 == strcmp(gSwitches[switchLoop]->mShortName, inArgv[loop]))
1116             {
1117                 match = __LINE__;
1118             }
1119
1120             if(match)
1121             {
1122                 if(gSwitches[switchLoop]->mHasValue)
1123                 {
1124                     /*
1125                     **  Attempt to absorb next option to fullfill value.
1126                     */
1127                     if(loop + 1 < inArgc)
1128                     {
1129                         loop++;
1130
1131                         current = gSwitches[switchLoop];
1132                         current->mValue = inArgv[loop];
1133                     }
1134                 }
1135                 else
1136                 {
1137                     current = gSwitches[switchLoop];
1138                 }
1139
1140                 break;
1141             }
1142         }
1143
1144         if(0 == match)
1145         {
1146             outOptions->mHelp = __LINE__;
1147             retval = __LINE__;
1148             ERROR_REPORT(retval, inArgv[loop], "Unknown command line switch.");
1149         }
1150         else if(NULL == current)
1151         {
1152             outOptions->mHelp = __LINE__;
1153             retval = __LINE__;
1154             ERROR_REPORT(retval, inArgv[loop], "Command line switch requires a value.");
1155         }
1156         else
1157         {
1158             /*
1159             ** Do something based on address/swtich.
1160             */
1161             if(current == &gInputSwitch)
1162             {
1163                 CLEANUP(outOptions->mInputName);
1164                 if(NULL != outOptions->mInput && stdin != outOptions->mInput)
1165                 {
1166                     fclose(outOptions->mInput);
1167                     outOptions->mInput = NULL;
1168                 }
1169
1170                 outOptions->mInput = fopen(current->mValue, "r");
1171                 if(NULL == outOptions->mInput)
1172                 {
1173                     retval = __LINE__;
1174                     ERROR_REPORT(retval, current->mValue, "Unable to open input file.");
1175                 }
1176                 else
1177                 {
1178                     outOptions->mInputName = strdup(current->mValue);
1179                     if(NULL == outOptions->mInputName)
1180                     {
1181                         retval = __LINE__;
1182                         ERROR_REPORT(retval, current->mValue, "Unable to strdup.");
1183                     }
1184                 }
1185             }
1186             else if(current == &gOutputSwitch)
1187             {
1188                 CLEANUP(outOptions->mOutputName);
1189                 if(NULL != outOptions->mOutput && stdout != outOptions->mOutput)
1190                 {
1191                     fclose(outOptions->mOutput);
1192                     outOptions->mOutput = NULL;
1193                 }
1194
1195                 outOptions->mOutput = fopen(current->mValue, "a");
1196                 if(NULL == outOptions->mOutput)
1197                 {
1198                     retval = __LINE__;
1199                     ERROR_REPORT(retval, current->mValue, "Unable to open output file.");
1200                 }
1201                 else
1202                 {
1203                     outOptions->mOutputName = strdup(current->mValue);
1204                     if(NULL == outOptions->mOutputName)
1205                     {
1206                         retval = __LINE__;
1207                         ERROR_REPORT(retval, current->mValue, "Unable to strdup.");
1208                     }
1209                 }
1210             }
1211             else if(current == &gHelpSwitch)
1212             {
1213                 outOptions->mHelp = __LINE__;
1214             }
1215             else if(current == &gSummarySwitch)
1216             {
1217                 outOptions->mSummaryOnly = __LINE__;
1218             }
1219             else if(current == &gZeroDriftSwitch)
1220             {
1221                 outOptions->mZeroDrift = __LINE__;
1222             }
1223             else if(current == &gNegationSwitch)
1224             {
1225                 outOptions->mNegation = __LINE__;
1226             }
1227             else
1228             {
1229                 retval = __LINE__;
1230                 ERROR_REPORT(retval, current->mLongName, "No handler for command line switch.");
1231             }
1232         }
1233     }
1234
1235     return retval;
1236 }
1237
1238
1239 void cleanOptions(Options* inOptions)
1240 /*
1241 **  Clean up any open handles.
1242 */
1243 {
1244     CLEANUP(inOptions->mInputName);
1245     if(NULL != inOptions->mInput && stdin != inOptions->mInput)
1246     {
1247         fclose(inOptions->mInput);
1248     }
1249     CLEANUP(inOptions->mOutputName);
1250     if(NULL != inOptions->mOutput && stdout != inOptions->mOutput)
1251     {
1252         fclose(inOptions->mOutput);
1253     }
1254
1255     memset(inOptions, 0, sizeof(Options));
1256 }
1257
1258
1259 void showHelp(Options* inOptions)
1260 /*
1261 **  Show some simple help text on usage.
1262 */
1263 {
1264     int loop = 0;
1265     const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]);
1266     const char* valueText = NULL;
1267
1268     printf("usage:\t%s [arguments]\n", inOptions->mProgramName);
1269     printf("\n");
1270     printf("arguments:\n");
1271
1272     for(loop = 0; loop < switchCount; loop++)
1273     {
1274         if(gSwitches[loop]->mHasValue)
1275         {
1276             valueText = " <value>";
1277         }
1278         else
1279         {
1280             valueText = "";
1281         }
1282
1283         printf("\t%s%s\n", gSwitches[loop]->mLongName, valueText);
1284         printf("\t %s%s", gSwitches[loop]->mShortName, valueText);
1285         printf(DESC_NEWLINE "%s\n\n", gSwitches[loop]->mDescription);
1286     }
1287
1288     printf("This tool takes the diff of two sorted tsv files to form a summary report\n");
1289     printf("of code and data size changes which is hoped to be human readable.\n");
1290 }
1291
1292
1293 int main(int inArgc, char** inArgv)
1294 {
1295     int retval = 0;
1296     Options options;
1297
1298     retval = initOptions(&options, inArgc, inArgv);
1299     if(options.mHelp)
1300     {
1301         showHelp(&options);
1302     }
1303     else if(0 == retval)
1304     {
1305         retval = difftool(&options);
1306     }
1307
1308     cleanOptions(&options);
1309     return retval;
1310 }
1311