summaryrefslogtreecommitdiffstats
path: root/third_party/codesighs/maptsvdifftool.c
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/codesighs/maptsvdifftool.c')
-rw-r--r--third_party/codesighs/maptsvdifftool.c1311
1 files changed, 1311 insertions, 0 deletions
diff --git a/third_party/codesighs/maptsvdifftool.c b/third_party/codesighs/maptsvdifftool.c
new file mode 100644
index 0000000..8207060
--- /dev/null
+++ b/third_party/codesighs/maptsvdifftool.c
@@ -0,0 +1,1311 @@
+/* -*- 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;
+}
+
generated by cgit v1.1 at 2025-01-11 00:39:23 +0000