| /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- |
| * |
| * ***** BEGIN LICENSE BLOCK ***** |
| * Version: MPL 1.1/GPL 2.0/LGPL 2.1 |
| * |
| * The contents of this file are subject to the Mozilla Public License Version |
| * 1.1 (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.mozilla.org/MPL/ |
| * |
| * Software distributed under the License is distributed on an "AS IS" basis, |
| * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License |
| * for the specific language governing rights and limitations under the |
| * License. |
| * |
| * The Original Code is maptsvdifftool.c code, released |
| * Oct 3, 2002. |
| * |
| * The Initial Developer of the Original Code is |
| * Netscape Communications Corporation. |
| * Portions created by the Initial Developer are Copyright (C) 2002 |
| * the Initial Developer. All Rights Reserved. |
| * |
| * Contributor(s): |
| * Garrett Arch Blythe, 03-October-2002 |
| * |
| * Alternatively, the contents of this file may be used under the terms of |
| * either the GNU General Public License Version 2 or later (the "GPL"), or |
| * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), |
| * in which case the provisions of the GPL or the LGPL are applicable instead |
| * of those above. If you wish to allow use of your version of this file only |
| * under the terms of either the GPL or the LGPL, and not to allow others to |
| * use your version of this file under the terms of the MPL, indicate your |
| * decision by deleting the provisions above and replace them with the notice |
| * and other provisions required by the GPL or the LGPL. If you do not delete |
| * the provisions above, a recipient may use your version of this file under |
| * the terms of any one of the MPL, the GPL or the LGPL. |
| * |
| * ***** END LICENSE BLOCK ***** */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <time.h> |
| #include <ctype.h> |
| |
| #define ERROR_REPORT(num, val, msg) fprintf(stderr, "error(%d):\t\"%s\"\t%s\n", (num), (val), (msg)); |
| #define CLEANUP(ptr) do { if(NULL != ptr) { free(ptr); ptr = NULL; } } while(0) |
| |
| |
| typedef struct __struct_Options |
| /* |
| ** Options to control how we perform. |
| ** |
| ** mProgramName Used in help text. |
| ** mInput File to read for input. |
| ** Default is stdin. |
| ** mInputName Name of the file. |
| ** mOutput Output file, append. |
| ** Default is stdout. |
| ** mOutputName Name of the file. |
| ** mHelp Whether or not help should be shown. |
| ** mSummaryOnly Only output a signle line. |
| ** mZeroDrift Output zero drift data. |
| ** mNegation Perform negation heuristics on the symbol drifts. |
| */ |
| { |
| const char* mProgramName; |
| FILE* mInput; |
| char* mInputName; |
| FILE* mOutput; |
| char* mOutputName; |
| int mHelp; |
| int mSummaryOnly; |
| int mZeroDrift; |
| int mNegation; |
| } |
| Options; |
| |
| |
| typedef struct __struct_Switch |
| /* |
| ** Command line options. |
| */ |
| { |
| const char* mLongName; |
| const char* mShortName; |
| int mHasValue; |
| const char* mValue; |
| const char* mDescription; |
| } |
| Switch; |
| |
| #define DESC_NEWLINE "\n\t\t" |
| |
| static Switch gInputSwitch = {"--input", "-i", 1, NULL, "Specify input file." DESC_NEWLINE "stdin is default."}; |
| static Switch gOutputSwitch = {"--output", "-o", 1, NULL, "Specify output file." DESC_NEWLINE "Appends if file exists." DESC_NEWLINE "stdout is default."}; |
| 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."}; |
| static Switch gZeroDriftSwitch = {"--zerodrift", "-z", 0, NULL, "Output zero drift data." DESC_NEWLINE "Reports symbol changes even when there is no net drift."}; |
| 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."}; |
| static Switch gHelpSwitch = {"--help", "-h", 0, NULL, "Information on usage."}; |
| |
| static Switch* gSwitches[] = { |
| &gInputSwitch, |
| &gOutputSwitch, |
| &gSummarySwitch, |
| &gZeroDriftSwitch, |
| &gNegationSwitch, |
| &gHelpSwitch |
| }; |
| |
| |
| typedef struct __struct_SizeComposition |
| /* |
| ** Used to keep which parts positive and negative resulted in the total. |
| */ |
| { |
| int mPositive; |
| int mNegative; |
| } |
| SizeComposition; |
| |
| |
| typedef struct __struct_SizeStats |
| /* |
| ** Keep track of sizes. |
| ** Use signed integers so that negatives are valid, in which case we shrunk. |
| */ |
| { |
| int mCode; |
| SizeComposition mCodeComposition; |
| |
| int mData; |
| SizeComposition mDataComposition; |
| } |
| SizeStats; |
| |
| |
| typedef enum __enum_SegmentClass |
| /* |
| ** What type of data a segment holds. |
| */ |
| { |
| CODE, |
| DATA |
| } |
| SegmentClass; |
| |
| |
| typedef struct __struct_SymbolStats |
| /* |
| ** Symbol level stats. |
| */ |
| { |
| char* mSymbol; |
| int mSize; |
| } |
| SymbolStats; |
| |
| |
| typedef struct __struct_ObjectStats |
| /* |
| ** Object level stats. |
| */ |
| { |
| char* mObject; |
| int mSize; |
| SizeComposition mComposition; |
| SymbolStats* mSymbols; |
| unsigned mSymbolCount; |
| } |
| ObjectStats; |
| |
| |
| typedef struct __struct_SegmentStats |
| /* |
| ** Segment level stats. |
| */ |
| { |
| char* mSegment; |
| SegmentClass mClass; |
| int mSize; |
| SizeComposition mComposition; |
| ObjectStats* mObjects; |
| unsigned mObjectCount; |
| } |
| SegmentStats; |
| |
| |
| typedef struct __struct_ModuleStats |
| /* |
| ** Module level stats. |
| */ |
| { |
| char* mModule; |
| SizeStats mSize; |
| SegmentStats* mSegments; |
| unsigned mSegmentCount; |
| } |
| ModuleStats; |
| |
| |
| static int moduleCompare(const void* in1, const void* in2) |
| /* |
| ** qsort helper. |
| */ |
| { |
| int retval = 0; |
| |
| ModuleStats* one = (ModuleStats*)in1; |
| ModuleStats* two = (ModuleStats*)in2; |
| |
| int oneSize = (one->mSize.mCode + one->mSize.mData); |
| int twoSize = (two->mSize.mCode + two->mSize.mData); |
| |
| if(oneSize < twoSize) |
| { |
| retval = 1; |
| } |
| else if(oneSize > twoSize) |
| { |
| retval = -1; |
| } |
| else |
| { |
| retval = strcmp(one->mModule, two->mModule); |
| if(0 > oneSize && 0 > twoSize) |
| { |
| retval *= -1; |
| } |
| } |
| |
| return retval; |
| } |
| |
| |
| static int segmentCompare(const void* in1, const void* in2) |
| /* |
| ** qsort helper. |
| */ |
| { |
| int retval = 0; |
| |
| SegmentStats* one = (SegmentStats*)in1; |
| SegmentStats* two = (SegmentStats*)in2; |
| |
| if(one->mSize < two->mSize) |
| { |
| retval = 1; |
| } |
| else if(one->mSize > two->mSize) |
| { |
| retval = -1; |
| } |
| else |
| { |
| retval = strcmp(one->mSegment, two->mSegment); |
| if(0 > one->mSize && 0 > two->mSize) |
| { |
| retval *= -1; |
| } |
| } |
| |
| return retval; |
| } |
| |
| |
| static int objectCompare(const void* in1, const void* in2) |
| /* |
| ** qsort helper. |
| */ |
| { |
| int retval = 0; |
| |
| ObjectStats* one = (ObjectStats*)in1; |
| ObjectStats* two = (ObjectStats*)in2; |
| |
| if(one->mSize < two->mSize) |
| { |
| retval = 1; |
| } |
| else if(one->mSize > two->mSize) |
| { |
| retval = -1; |
| } |
| else |
| { |
| retval = strcmp(one->mObject, two->mObject); |
| if(0 > one->mSize && 0 > two->mSize) |
| { |
| retval *= -1; |
| } |
| } |
| |
| return retval; |
| } |
| |
| |
| static int symbolCompare(const void* in1, const void* in2) |
| /* |
| ** qsort helper. |
| */ |
| { |
| int retval = 0; |
| |
| SymbolStats* one = (SymbolStats*)in1; |
| SymbolStats* two = (SymbolStats*)in2; |
| |
| if(one->mSize < two->mSize) |
| { |
| retval = 1; |
| } |
| else if(one->mSize > two->mSize) |
| { |
| retval = -1; |
| } |
| else |
| { |
| retval = strcmp(one->mSymbol, two->mSymbol); |
| if(0 > one->mSize && 0 > two->mSize) |
| { |
| retval *= -1; |
| } |
| } |
| |
| return retval; |
| } |
| |
| |
| void trimWhite(char* inString) |
| /* |
| ** Remove any whitespace from the end of the string. |
| */ |
| { |
| int len = strlen(inString); |
| |
| while(len) |
| { |
| len--; |
| |
| if(isspace(*(inString + len))) |
| { |
| *(inString + len) = '\0'; |
| } |
| else |
| { |
| break; |
| } |
| } |
| } |
| |
| |
| int difftool(Options* inOptions) |
| /* |
| ** Read a diff file and spit out relevant information. |
| */ |
| { |
| int retval = 0; |
| char lineBuffer[0x500]; |
| SizeStats overall; |
| ModuleStats* modules = NULL; |
| unsigned moduleCount = 0; |
| unsigned moduleLoop = 0; |
| ModuleStats* theModule = NULL; |
| unsigned segmentLoop = 0; |
| SegmentStats* theSegment = NULL; |
| unsigned objectLoop = 0; |
| ObjectStats* theObject = NULL; |
| unsigned symbolLoop = 0; |
| SymbolStats* theSymbol = NULL; |
| unsigned allSymbolCount = 0; |
| |
| memset(&overall, 0, sizeof(overall)); |
| |
| /* |
| ** Read the entire diff file. |
| ** We're only interested in lines beginning with < or > |
| */ |
| while(0 == retval && NULL != fgets(lineBuffer, sizeof(lineBuffer), inOptions->mInput)) |
| { |
| trimWhite(lineBuffer); |
| |
| if(('<' == lineBuffer[0] || '>' == lineBuffer[0]) && ' ' == lineBuffer[1]) |
| { |
| int additive = 0; |
| char* theLine = &lineBuffer[2]; |
| int scanRes = 0; |
| int size; |
| char segClass[0x10]; |
| char scope[0x10]; |
| char module[0x100]; |
| char segment[0x40]; |
| char object[0x100]; |
| char* symbol = NULL; |
| |
| /* |
| ** Figure out if the line adds or subtracts from something. |
| */ |
| if('>' == lineBuffer[0]) |
| { |
| additive = __LINE__; |
| } |
| |
| |
| /* |
| ** Scan the line for information. |
| */ |
| scanRes = sscanf(theLine, |
| "%x\t%s\t%s\t%s\t%s\t%s\t", |
| (unsigned*)&size, |
| segClass, |
| scope, |
| module, |
| segment, |
| object); |
| |
| if(6 == scanRes) |
| { |
| SegmentClass segmentClass = DATA; |
| |
| symbol = strrchr(theLine, '\t') + 1; |
| |
| if(0 == strcmp(segClass, "CODE")) |
| { |
| segmentClass = CODE; |
| } |
| else if(0 == strcmp(segClass, "DATA")) |
| { |
| segmentClass = DATA; |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, segClass, "Unable to determine segment class."); |
| } |
| |
| if(0 == retval) |
| { |
| unsigned moduleIndex = 0; |
| |
| /* |
| ** Find, in succession, the following things: |
| ** the module |
| ** the segment |
| ** the object |
| ** the symbol |
| ** Failure to find any one of these means to create it. |
| */ |
| |
| for(moduleIndex = 0; moduleIndex < moduleCount; moduleIndex++) |
| { |
| if(0 == strcmp(modules[moduleIndex].mModule, module)) |
| { |
| break; |
| } |
| } |
| |
| if(moduleIndex == moduleCount) |
| { |
| void* moved = NULL; |
| |
| moved = realloc(modules, sizeof(ModuleStats) * (1 + moduleCount)); |
| if(NULL != moved) |
| { |
| modules = (ModuleStats*)moved; |
| moduleCount++; |
| memset(modules + moduleIndex, 0, sizeof(ModuleStats)); |
| |
| modules[moduleIndex].mModule = strdup(module); |
| if(NULL == modules[moduleIndex].mModule) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, module, "Unable to duplicate string."); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inOptions->mProgramName, "Unable to increase module array."); |
| } |
| } |
| |
| if(0 == retval) |
| { |
| unsigned segmentIndex = 0; |
| theModule = (modules + moduleIndex); |
| |
| for(segmentIndex = 0; segmentIndex < theModule->mSegmentCount; segmentIndex++) |
| { |
| if(0 == strcmp(segment, theModule->mSegments[segmentIndex].mSegment)) |
| { |
| break; |
| } |
| } |
| |
| if(segmentIndex == theModule->mSegmentCount) |
| { |
| void* moved = NULL; |
| |
| moved = realloc(theModule->mSegments, sizeof(SegmentStats) * (theModule->mSegmentCount + 1)); |
| if(NULL != moved) |
| { |
| theModule->mSegments = (SegmentStats*)moved; |
| theModule->mSegmentCount++; |
| memset(theModule->mSegments + segmentIndex, 0, sizeof(SegmentStats)); |
| |
| theModule->mSegments[segmentIndex].mClass = segmentClass; |
| theModule->mSegments[segmentIndex].mSegment = strdup(segment); |
| if(NULL == theModule->mSegments[segmentIndex].mSegment) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, segment, "Unable to duplicate string."); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inOptions->mProgramName, "Unable to increase segment array."); |
| } |
| } |
| |
| if(0 == retval) |
| { |
| unsigned objectIndex = 0; |
| theSegment = (theModule->mSegments + segmentIndex); |
| |
| for(objectIndex = 0; objectIndex < theSegment->mObjectCount; objectIndex++) |
| { |
| if(0 == strcmp(object, theSegment->mObjects[objectIndex].mObject)) |
| { |
| break; |
| } |
| } |
| |
| if(objectIndex == theSegment->mObjectCount) |
| { |
| void* moved = NULL; |
| |
| moved = realloc(theSegment->mObjects, sizeof(ObjectStats) * (1 + theSegment->mObjectCount)); |
| if(NULL != moved) |
| { |
| theSegment->mObjects = (ObjectStats*)moved; |
| theSegment->mObjectCount++; |
| memset(theSegment->mObjects + objectIndex, 0, sizeof(ObjectStats)); |
| |
| theSegment->mObjects[objectIndex].mObject = strdup(object); |
| if(NULL == theSegment->mObjects[objectIndex].mObject) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, object, "Unable to duplicate string."); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inOptions->mProgramName, "Unable to increase object array."); |
| } |
| } |
| |
| if(0 == retval) |
| { |
| unsigned symbolIndex = 0; |
| theObject = (theSegment->mObjects + objectIndex); |
| |
| for(symbolIndex = 0; symbolIndex < theObject->mSymbolCount; symbolIndex++) |
| { |
| if(0 == strcmp(symbol, theObject->mSymbols[symbolIndex].mSymbol)) |
| { |
| break; |
| } |
| } |
| |
| if(symbolIndex == theObject->mSymbolCount) |
| { |
| void* moved = NULL; |
| |
| moved = realloc(theObject->mSymbols, sizeof(SymbolStats) * (1 + theObject->mSymbolCount)); |
| if(NULL != moved) |
| { |
| theObject->mSymbols = (SymbolStats*)moved; |
| theObject->mSymbolCount++; |
| allSymbolCount++; |
| memset(theObject->mSymbols + symbolIndex, 0, sizeof(SymbolStats)); |
| |
| theObject->mSymbols[symbolIndex].mSymbol = strdup(symbol); |
| if(NULL == theObject->mSymbols[symbolIndex].mSymbol) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, symbol, "Unable to duplicate string."); |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inOptions->mProgramName, "Unable to increase symbol array."); |
| } |
| } |
| |
| if(0 == retval) |
| { |
| theSymbol = (theObject->mSymbols + symbolIndex); |
| |
| /* |
| ** Update our various totals. |
| */ |
| if(additive) |
| { |
| if(CODE == segmentClass) |
| { |
| overall.mCode += size; |
| theModule->mSize.mCode += size; |
| } |
| else if(DATA == segmentClass) |
| { |
| overall.mData += size; |
| theModule->mSize.mData += size; |
| } |
| |
| theSegment->mSize += size; |
| theObject->mSize += size; |
| theSymbol->mSize += size; |
| } |
| else |
| { |
| if(CODE == segmentClass) |
| { |
| overall.mCode -= size; |
| theModule->mSize.mCode -= size; |
| } |
| else if(DATA == segmentClass) |
| { |
| overall.mData -= size; |
| theModule->mSize.mData -= size; |
| } |
| |
| theSegment->mSize -= size; |
| theObject->mSize -= size; |
| theSymbol->mSize -= size; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inOptions->mInputName, "Unable to scan line data."); |
| } |
| } |
| } |
| |
| if(0 == retval && 0 != ferror(inOptions->mInput)) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inOptions->mInputName, "Unable to read file."); |
| } |
| |
| /* |
| ** Next, it is time to perform revisionist history of sorts. |
| ** If the negation switch is in play, we perfrom the following |
| ** aggressive steps: |
| ** |
| ** For each section, find size changes which have an equal and |
| ** opposite change, and set them both to zero. |
| ** However, you can only do this if the number of negating changes |
| ** is even, as if it is odd, then any one of the many could be |
| ** at fault for the actual change. |
| ** |
| ** This orginally exists to make the win32 codesighs reports more |
| ** readable/meaningful. |
| */ |
| if(0 == retval && 0 != inOptions->mNegation) |
| { |
| ObjectStats** objArray = NULL; |
| SymbolStats** symArray = NULL; |
| |
| /* |
| ** Create arrays big enough to hold all symbols. |
| ** As well as an array to keep the owning object at the same index. |
| ** We will keep the object around as we may need to modify the size. |
| */ |
| objArray = (ObjectStats**)malloc(allSymbolCount * sizeof(ObjectStats*)); |
| symArray = (SymbolStats**)malloc(allSymbolCount * sizeof(SymbolStats*)); |
| if(NULL == objArray || NULL == symArray) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, inOptions->mProgramName, "Unable to allocate negation array memory."); |
| } |
| else |
| { |
| unsigned arrayCount = 0; |
| unsigned arrayLoop = 0; |
| |
| /* |
| ** Go through and perform the steps on each section/segment. |
| */ |
| for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++) |
| { |
| theModule = modules + moduleLoop; |
| |
| for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++) |
| { |
| theSegment = theModule->mSegments + segmentLoop; |
| |
| /* |
| ** Collect all symbols under this section. |
| ** The symbols are spread out between all the objects, |
| ** so keep track of both independently at the |
| ** same index. |
| */ |
| arrayCount = 0; |
| |
| for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++) |
| { |
| theObject = theSegment->mObjects + objectLoop; |
| |
| for(symbolLoop = 0; symbolLoop < theObject->mSymbolCount; symbolLoop++) |
| { |
| theSymbol = theObject->mSymbols + symbolLoop; |
| |
| objArray[arrayCount] = theObject; |
| symArray[arrayCount] = theSymbol; |
| arrayCount++; |
| } |
| } |
| |
| /* |
| ** Now that we have a list of symbols, go through each |
| ** and see if there is a chance of negation. |
| */ |
| for(arrayLoop = 0; arrayLoop < arrayCount; arrayLoop++) |
| { |
| /* |
| ** If the item is NULL, it was already negated. |
| ** Don't do this for items with a zero size. |
| */ |
| if(NULL != symArray[arrayLoop] && 0 != symArray[arrayLoop]->mSize) |
| { |
| unsigned identicalValues = 0; |
| unsigned oppositeValues = 0; |
| unsigned lookLoop = 0; |
| const int lookingFor = symArray[arrayLoop]->mSize; |
| |
| /* |
| ** Count the number of items with this value. |
| ** Count the number of items with the opposite equal value. |
| ** If they are equal, go through and negate all sizes. |
| */ |
| for(lookLoop = arrayLoop; lookLoop < arrayCount; lookLoop++) |
| { |
| /* |
| ** Skip negated items. |
| ** Skip zero length items. |
| */ |
| if(NULL == symArray[lookLoop] || 0 == symArray[lookLoop]->mSize) |
| { |
| continue; |
| } |
| |
| if(lookingFor == symArray[lookLoop]->mSize) |
| { |
| identicalValues++; |
| } |
| else if((-1 * lookingFor) == symArray[lookLoop]->mSize) |
| { |
| oppositeValues++; |
| } |
| } |
| |
| if(0 != identicalValues && identicalValues == oppositeValues) |
| { |
| unsigned negationLoop = 0; |
| |
| for(negationLoop = arrayLoop; 0 != identicalValues || 0 != oppositeValues; negationLoop++) |
| { |
| /* |
| ** Skip negated items. |
| ** Skip zero length items. |
| */ |
| if(NULL == symArray[negationLoop] || 0 == symArray[negationLoop]->mSize) |
| { |
| continue; |
| } |
| |
| /* |
| ** Negate any size matches. |
| ** Reflect the change in the object as well. |
| ** Clear the symbol. |
| */ |
| if(lookingFor == symArray[negationLoop]->mSize) |
| { |
| objArray[negationLoop]->mSize -= lookingFor; |
| symArray[negationLoop]->mSize = 0; |
| symArray[negationLoop] = NULL; |
| |
| identicalValues--; |
| } |
| else if((-1 * lookingFor) == symArray[negationLoop]->mSize) |
| { |
| objArray[negationLoop]->mSize += lookingFor; |
| symArray[negationLoop]->mSize = 0; |
| symArray[negationLoop] = NULL; |
| |
| oppositeValues--; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| CLEANUP(objArray); |
| CLEANUP(symArray); |
| } |
| |
| |
| /* |
| ** If all went well, time to report. |
| */ |
| if(0 == retval) |
| { |
| /* |
| ** Loop through our data once more, so that the symbols can |
| ** propigate their changes upwards in a positive/negative |
| ** fashion. |
| ** This will help give the composite change more meaning. |
| */ |
| for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++) |
| { |
| theModule = modules + moduleLoop; |
| |
| /* |
| ** Skip if there is zero drift, or no net change. |
| */ |
| if(0 == inOptions->mZeroDrift && 0 == (theModule->mSize.mCode + theModule->mSize.mData)) |
| { |
| continue; |
| } |
| |
| for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++) |
| { |
| theSegment = theModule->mSegments + segmentLoop; |
| |
| /* |
| ** Skip if there is zero drift, or no net change. |
| */ |
| if(0 == inOptions->mZeroDrift && 0 == theSegment->mSize) |
| { |
| continue; |
| } |
| |
| for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++) |
| { |
| theObject = theSegment->mObjects + objectLoop; |
| |
| /* |
| ** Skip if there is zero drift, or no net change. |
| */ |
| if(0 == inOptions->mZeroDrift && 0 == theObject->mSize) |
| { |
| continue; |
| } |
| |
| for(symbolLoop = 0; symbolLoop < theObject->mSymbolCount; symbolLoop++) |
| { |
| theSymbol = theObject->mSymbols + symbolLoop; |
| |
| /* |
| ** Propagate the composition all the way to the top. |
| ** Sizes of zero change are skipped. |
| */ |
| if(0 < theSymbol->mSize) |
| { |
| theObject->mComposition.mPositive += theSymbol->mSize; |
| theSegment->mComposition.mPositive += theSymbol->mSize; |
| if(CODE == theSegment->mClass) |
| { |
| overall.mCodeComposition.mPositive += theSymbol->mSize; |
| theModule->mSize.mCodeComposition.mPositive += theSymbol->mSize; |
| } |
| else if(DATA == theSegment->mClass) |
| { |
| overall.mDataComposition.mPositive += theSymbol->mSize; |
| theModule->mSize.mDataComposition.mPositive += theSymbol->mSize; |
| } |
| } |
| else if(0 > theSymbol->mSize) |
| { |
| theObject->mComposition.mNegative += theSymbol->mSize; |
| theSegment->mComposition.mNegative += theSymbol->mSize; |
| if(CODE == theSegment->mClass) |
| { |
| overall.mCodeComposition.mNegative += theSymbol->mSize; |
| theModule->mSize.mCodeComposition.mNegative += theSymbol->mSize; |
| } |
| else if(DATA == theSegment->mClass) |
| { |
| overall.mDataComposition.mNegative += theSymbol->mSize; |
| theModule->mSize.mDataComposition.mNegative += theSymbol->mSize; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| |
| if(inOptions->mSummaryOnly) |
| { |
| fprintf(inOptions->mOutput, "%+d (%+d/%+d)\n", overall.mCode + overall.mData, overall.mCodeComposition.mPositive + overall.mDataComposition.mPositive, overall.mCodeComposition.mNegative + overall.mDataComposition.mNegative); |
| } |
| else |
| { |
| fprintf(inOptions->mOutput, "Overall Change in Size\n"); |
| 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); |
| fprintf(inOptions->mOutput, "\tCode:\t%+11d (%+d/%+d)\n", overall.mCode, overall.mCodeComposition.mPositive, overall.mCodeComposition.mNegative); |
| fprintf(inOptions->mOutput, "\tData:\t%+11d (%+d/%+d)\n", overall.mData, overall.mDataComposition.mPositive, overall.mDataComposition.mNegative); |
| } |
| |
| /* |
| ** Check what else we should output. |
| */ |
| if(0 == inOptions->mSummaryOnly && NULL != modules && moduleCount) |
| { |
| const char* segmentType = NULL; |
| |
| /* |
| ** We're going to sort everything. |
| */ |
| qsort(modules, moduleCount, sizeof(ModuleStats), moduleCompare); |
| for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++) |
| { |
| theModule = modules + moduleLoop; |
| |
| qsort(theModule->mSegments, theModule->mSegmentCount, sizeof(SegmentStats), segmentCompare); |
| |
| for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++) |
| { |
| theSegment = theModule->mSegments + segmentLoop; |
| |
| qsort(theSegment->mObjects, theSegment->mObjectCount, sizeof(ObjectStats), objectCompare); |
| |
| for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++) |
| { |
| theObject = theSegment->mObjects + objectLoop; |
| |
| qsort(theObject->mSymbols, theObject->mSymbolCount, sizeof(SymbolStats), symbolCompare); |
| } |
| } |
| } |
| |
| /* |
| ** Loop through for output. |
| */ |
| for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++) |
| { |
| theModule = modules + moduleLoop; |
| |
| /* |
| ** Skip if there is zero drift, or no net change. |
| */ |
| if(0 == inOptions->mZeroDrift && 0 == (theModule->mSize.mCode + theModule->mSize.mData)) |
| { |
| continue; |
| } |
| |
| fprintf(inOptions->mOutput, "\n"); |
| fprintf(inOptions->mOutput, "%s\n", theModule->mModule); |
| 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); |
| fprintf(inOptions->mOutput, "\tCode:\t%+11d (%+d/%+d)\n", theModule->mSize.mCode, theModule->mSize.mCodeComposition.mPositive, theModule->mSize.mCodeComposition.mNegative); |
| fprintf(inOptions->mOutput, "\tData:\t%+11d (%+d/%+d)\n", theModule->mSize.mData, theModule->mSize.mDataComposition.mPositive, theModule->mSize.mDataComposition.mNegative); |
| |
| for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++) |
| { |
| theSegment = theModule->mSegments + segmentLoop; |
| |
| /* |
| ** Skip if there is zero drift, or no net change. |
| */ |
| if(0 == inOptions->mZeroDrift && 0 == theSegment->mSize) |
| { |
| continue; |
| } |
| |
| if(CODE == theSegment->mClass) |
| { |
| segmentType = "CODE"; |
| } |
| else if(DATA == theSegment->mClass) |
| { |
| segmentType = "DATA"; |
| } |
| |
| fprintf(inOptions->mOutput, "\t%+11d (%+d/%+d)\t%s (%s)\n", theSegment->mSize, theSegment->mComposition.mPositive, theSegment->mComposition.mNegative, theSegment->mSegment, segmentType); |
| |
| for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++) |
| { |
| theObject = theSegment->mObjects + objectLoop; |
| |
| /* |
| ** Skip if there is zero drift, or no net change. |
| */ |
| if(0 == inOptions->mZeroDrift && 0 == theObject->mSize) |
| { |
| continue; |
| } |
| |
| fprintf(inOptions->mOutput, "\t\t%+11d (%+d/%+d)\t%s\n", theObject->mSize, theObject->mComposition.mPositive, theObject->mComposition.mNegative, theObject->mObject); |
| |
| for(symbolLoop = 0; symbolLoop < theObject->mSymbolCount; symbolLoop++) |
| { |
| theSymbol = theObject->mSymbols + symbolLoop; |
| |
| /* |
| ** Skip if there is zero drift, or no net change. |
| */ |
| if(0 == inOptions->mZeroDrift && 0 == theSymbol->mSize) |
| { |
| continue; |
| } |
| |
| fprintf(inOptions->mOutput, "\t\t\t%+11d\t%s\n", theSymbol->mSize, theSymbol->mSymbol); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| ** Cleanup time. |
| */ |
| for(moduleLoop = 0; moduleLoop < moduleCount; moduleLoop++) |
| { |
| theModule = modules + moduleLoop; |
| |
| for(segmentLoop = 0; segmentLoop < theModule->mSegmentCount; segmentLoop++) |
| { |
| theSegment = theModule->mSegments + segmentLoop; |
| |
| for(objectLoop = 0; objectLoop < theSegment->mObjectCount; objectLoop++) |
| { |
| theObject = theSegment->mObjects + objectLoop; |
| |
| for(symbolLoop = 0; symbolLoop < theObject->mSymbolCount; symbolLoop++) |
| { |
| theSymbol = theObject->mSymbols + symbolLoop; |
| |
| CLEANUP(theSymbol->mSymbol); |
| } |
| |
| CLEANUP(theObject->mSymbols); |
| CLEANUP(theObject->mObject); |
| } |
| |
| CLEANUP(theSegment->mObjects); |
| CLEANUP(theSegment->mSegment); |
| } |
| |
| CLEANUP(theModule->mSegments); |
| CLEANUP(theModule->mModule); |
| } |
| CLEANUP(modules); |
| |
| return retval; |
| } |
| |
| |
| int initOptions(Options* outOptions, int inArgc, char** inArgv) |
| /* |
| ** returns int 0 if successful. |
| */ |
| { |
| int retval = 0; |
| int loop = 0; |
| int switchLoop = 0; |
| int match = 0; |
| const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]); |
| Switch* current = NULL; |
| |
| /* |
| ** Set any defaults. |
| */ |
| memset(outOptions, 0, sizeof(Options)); |
| outOptions->mProgramName = inArgv[0]; |
| outOptions->mInput = stdin; |
| outOptions->mInputName = strdup("stdin"); |
| outOptions->mOutput = stdout; |
| outOptions->mOutputName = strdup("stdout"); |
| |
| if(NULL == outOptions->mOutputName || NULL == outOptions->mInputName) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, "stdin/stdout", "Unable to strdup."); |
| } |
| |
| /* |
| ** Go through and attempt to do the right thing. |
| */ |
| for(loop = 1; loop < inArgc && 0 == retval; loop++) |
| { |
| match = 0; |
| current = NULL; |
| |
| for(switchLoop = 0; switchLoop < switchCount && 0 == retval; switchLoop++) |
| { |
| if(0 == strcmp(gSwitches[switchLoop]->mLongName, inArgv[loop])) |
| { |
| match = __LINE__; |
| } |
| else if(0 == strcmp(gSwitches[switchLoop]->mShortName, inArgv[loop])) |
| { |
| match = __LINE__; |
| } |
| |
| if(match) |
| { |
| if(gSwitches[switchLoop]->mHasValue) |
| { |
| /* |
| ** Attempt to absorb next option to fullfill value. |
| */ |
| if(loop + 1 < inArgc) |
| { |
| loop++; |
| |
| current = gSwitches[switchLoop]; |
| current->mValue = inArgv[loop]; |
| } |
| } |
| else |
| { |
| current = gSwitches[switchLoop]; |
| } |
| |
| break; |
| } |
| } |
| |
| if(0 == match) |
| { |
| outOptions->mHelp = __LINE__; |
| retval = __LINE__; |
| ERROR_REPORT(retval, inArgv[loop], "Unknown command line switch."); |
| } |
| else if(NULL == current) |
| { |
| outOptions->mHelp = __LINE__; |
| retval = __LINE__; |
| ERROR_REPORT(retval, inArgv[loop], "Command line switch requires a value."); |
| } |
| else |
| { |
| /* |
| ** Do something based on address/swtich. |
| */ |
| if(current == &gInputSwitch) |
| { |
| CLEANUP(outOptions->mInputName); |
| if(NULL != outOptions->mInput && stdin != outOptions->mInput) |
| { |
| fclose(outOptions->mInput); |
| outOptions->mInput = NULL; |
| } |
| |
| outOptions->mInput = fopen(current->mValue, "r"); |
| if(NULL == outOptions->mInput) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mValue, "Unable to open input file."); |
| } |
| else |
| { |
| outOptions->mInputName = strdup(current->mValue); |
| if(NULL == outOptions->mInputName) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mValue, "Unable to strdup."); |
| } |
| } |
| } |
| else if(current == &gOutputSwitch) |
| { |
| CLEANUP(outOptions->mOutputName); |
| if(NULL != outOptions->mOutput && stdout != outOptions->mOutput) |
| { |
| fclose(outOptions->mOutput); |
| outOptions->mOutput = NULL; |
| } |
| |
| outOptions->mOutput = fopen(current->mValue, "a"); |
| if(NULL == outOptions->mOutput) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mValue, "Unable to open output file."); |
| } |
| else |
| { |
| outOptions->mOutputName = strdup(current->mValue); |
| if(NULL == outOptions->mOutputName) |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mValue, "Unable to strdup."); |
| } |
| } |
| } |
| else if(current == &gHelpSwitch) |
| { |
| outOptions->mHelp = __LINE__; |
| } |
| else if(current == &gSummarySwitch) |
| { |
| outOptions->mSummaryOnly = __LINE__; |
| } |
| else if(current == &gZeroDriftSwitch) |
| { |
| outOptions->mZeroDrift = __LINE__; |
| } |
| else if(current == &gNegationSwitch) |
| { |
| outOptions->mNegation = __LINE__; |
| } |
| else |
| { |
| retval = __LINE__; |
| ERROR_REPORT(retval, current->mLongName, "No handler for command line switch."); |
| } |
| } |
| } |
| |
| return retval; |
| } |
| |
| |
| void cleanOptions(Options* inOptions) |
| /* |
| ** Clean up any open handles. |
| */ |
| { |
| CLEANUP(inOptions->mInputName); |
| if(NULL != inOptions->mInput && stdin != inOptions->mInput) |
| { |
| fclose(inOptions->mInput); |
| } |
| CLEANUP(inOptions->mOutputName); |
| if(NULL != inOptions->mOutput && stdout != inOptions->mOutput) |
| { |
| fclose(inOptions->mOutput); |
| } |
| |
| memset(inOptions, 0, sizeof(Options)); |
| } |
| |
| |
| void showHelp(Options* inOptions) |
| /* |
| ** Show some simple help text on usage. |
| */ |
| { |
| int loop = 0; |
| const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]); |
| const char* valueText = NULL; |
| |
| printf("usage:\t%s [arguments]\n", inOptions->mProgramName); |
| printf("\n"); |
| printf("arguments:\n"); |
| |
| for(loop = 0; loop < switchCount; loop++) |
| { |
| if(gSwitches[loop]->mHasValue) |
| { |
| valueText = " <value>"; |
| } |
| else |
| { |
| valueText = ""; |
| } |
| |
| printf("\t%s%s\n", gSwitches[loop]->mLongName, valueText); |
| printf("\t %s%s", gSwitches[loop]->mShortName, valueText); |
| printf(DESC_NEWLINE "%s\n\n", gSwitches[loop]->mDescription); |
| } |
| |
| printf("This tool takes the diff of two sorted tsv files to form a summary report\n"); |
| printf("of code and data size changes which is hoped to be human readable.\n"); |
| } |
| |
| |
| int main(int inArgc, char** inArgv) |
| { |
| int retval = 0; |
| Options options; |
| |
| retval = initOptions(&options, inArgc, inArgv); |
| if(options.mHelp) |
| { |
| showHelp(&options); |
| } |
| else if(0 == retval) |
| { |
| retval = difftool(&options); |
| } |
| |
| cleanOptions(&options); |
| return retval; |
| } |
| |
