Capture Mozilla's codesighs, for use in executable sizing.

Vanilla code, no changes, except for the addition of:
* LICENSE, copied from elsewhere in the Mozilla tree;
* README.chromium, documenting what's going on.
* codesighs.gyp, for building with the rest of Chromium.
Review URL: http://codereview.chromium.org/93155

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@14522 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 1075 insertions, 0 deletions

diff --git a/third_party/codesighs/codesighs.c b/third_party/codesighs/codesighs.c
new file mode 100644
index 0000000..f20fbb1
--- /dev/null
+++ b/third_party/codesighs/codesighs.c
@@ -0,0 +1,1075 @@
+/* -*- 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 codesighs.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>
+#include <errno.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.
+**  mModules        Output module by module information.
+**  mTotalOnly      Only output one number, the total.
+**  mMinSize        Ignore lines below this size.
+**  mMaxSize        Ignore lines above this size.
+**  mMatchScopes    For a line to be processed, it should match.
+**  mMachClasses    For a line to be processed, it should match.
+**  mMatchModules   For a line to be processed, it should match.
+**  mMatchSections  For a line to be processed, it should match.
+**  mMatchObjects   For a line to be processed, it should match.
+**  mMatchSymbols   For a line to be processed, it should match.
+*/
+{
+    const char* mProgramName;
+    FILE* mInput;
+    char* mInputName;
+    FILE* mOutput;
+    char* mOutputName;
+    int mHelp;
+    int mModules;
+    int mTotalOnly;
+    unsigned long mMinSize;
+    unsigned long mMaxSize;
+    char** mMatchScopes;
+    unsigned mMatchScopeCount;
+    char** mMatchClasses;
+    unsigned mMatchClassCount;
+    char** mMatchModules;
+    unsigned mMatchModuleCount;
+    char** mMatchSections;
+    unsigned mMatchSectionCount;
+    char** mMatchObjects;
+    unsigned mMatchObjectCount;
+    char** mMatchSymbols;
+    unsigned mMatchSymbolCount;
+}
+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 gHelpSwitch = {"--help", "-h", 0, NULL, "Information on usage."};
+static Switch gModuleSwitch = {"--modules", "-m", 0, NULL, "Output individual module numbers as well."};
+static Switch gTotalSwitch = {"--totalonly", "-t", 0, NULL, "Output only one number." DESC_NEWLINE "The total overall size." DESC_NEWLINE "Overrides other output options."};
+static Switch gMinSize = {"--min-size", "-min", 1, NULL, "Only consider symbols equal to or greater than this size." DESC_NEWLINE "The default is 0x00000000."};
+static Switch gMaxSize = {"--max-size", "-max", 1, NULL, "Only consider symbols equal to or smaller than this size." DESC_NEWLINE "The default is 0xFFFFFFFF."};
+static Switch gMatchScope = {"--match-scope", "-msco", 1, NULL, "Only consider scopes that have a substring match." DESC_NEWLINE "Multiple uses allowed to specify a range of scopes," DESC_NEWLINE "though PUBLIC, STATIC, and UNDEF are your only choices."};
+static Switch gMatchClass = {"--match-class", "-mcla", 1, NULL, "Only consider classes that have a substring match." DESC_NEWLINE "Multiple uses allowed to specify a range of classes," DESC_NEWLINE "though CODE and DATA are your only choices."};
+static Switch gMatchModule = {"--match-module", "-mmod", 1, NULL, "Only consider modules that have a substring match." DESC_NEWLINE "Multiple uses allowed to specify an array of modules."};
+static Switch gMatchSection = {"--match-section", "-msec", 1, NULL, "Only consider sections that have a substring match." DESC_NEWLINE "Multiple uses allowed to specify an array of sections."  DESC_NEWLINE "Section is considered symbol type."};
+static Switch gMatchObject = {"--match-object", "-mobj", 1, NULL, "Only consider objects that have a substring match." DESC_NEWLINE "Multiple uses allowed to specify an array of objects."};
+static Switch gMatchSymbol = {"--match-symbol", "-msym", 1, NULL, "Only consider symbols that have a substring match." DESC_NEWLINE "Multiple uses allowed to specify an array of symbols."};
+
+static Switch* gSwitches[] = {
+        &gInputSwitch,
+        &gOutputSwitch,
+        &gModuleSwitch,
+        &gTotalSwitch,
+        &gMinSize,
+        &gMaxSize,
+        &gMatchClass,
+        &gMatchScope,
+        &gMatchModule,
+        &gMatchSection,
+        &gMatchObject,
+        &gMatchSymbol,
+        &gHelpSwitch
+};
+
+
+typedef struct __struct_SizeStats
+/*
+**  Track totals.
+**
+**  mData       Size of data.
+**  mCode       Size of code.
+*/
+{
+    unsigned long mData;
+    unsigned long mCode;
+}
+SizeStats;
+
+
+typedef struct __struct_ModuleStats
+/*
+**  Track module level information.
+**
+**  mModule     Module name.
+**  mSize       Size of module.
+*/
+{
+    char* mModule;
+    SizeStats mSize;
+}
+ModuleStats;
+
+typedef enum __enum_SegmentClass
+{
+        CODE,
+        DATA
+}
+SegmentClass;
+
+
+static int moduleCompare(const void* in1, const void* in2)
+/*
+**  qsort helper function.
+*/
+{
+    int retval = 0;
+
+    const ModuleStats* one = (const ModuleStats*)in1;
+    const ModuleStats* two = (const ModuleStats*)in2;
+    unsigned long oneSize = one->mSize.mCode + one->mSize.mData;
+    unsigned long twoSize = two->mSize.mCode + two->mSize.mData;
+
+    if(oneSize < twoSize)
+    {
+        retval = 1;
+    }
+    else if(oneSize > twoSize)
+    {
+        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 codesighs(Options* inOptions)
+/*
+**  Output a simplistic report based on our options.
+*/
+{
+    int retval = 0;
+    char lineBuffer[0x1000];
+    int scanRes = 0;
+    unsigned long size;
+    char segClass[0x10];
+    char scope[0x10];
+    char module[0x100];
+    char segment[0x40];
+    char object[0x100];
+    char* symbol;
+    SizeStats overall;
+    ModuleStats* modules = NULL;
+    unsigned moduleCount = 0;
+
+    memset(&overall, 0, sizeof(overall));
+
+    /*
+    **  Read the file line by line, regardless of number of fields.
+    **  We assume tab separated value formatting, at least 7 lead values:
+    **      size class scope module segment object symbol ....
+    */
+    while(0 == retval && NULL != fgets(lineBuffer, sizeof(lineBuffer), inOptions->mInput))
+    {
+        trimWhite(lineBuffer);
+
+        scanRes = sscanf(lineBuffer,
+            "%x\t%s\t%s\t%s\t%s\t%s\t",
+            (unsigned*)&size,
+            segClass,
+            scope,
+            module,
+            segment,
+            object);
+
+        if(6 == scanRes)
+        {
+            SegmentClass segmentClass = CODE;
+
+            symbol = strchr(lineBuffer, '\t') + 1;
+
+            /*
+            **  Qualify the segment class.
+            */
+            if(0 == strcmp(segClass, "DATA"))
+            {
+                segmentClass = DATA;
+            }
+            else if(0 == strcmp(segClass, "CODE"))
+            {
+                segmentClass = CODE;
+            }
+            else
+            {
+                retval = __LINE__;
+                ERROR_REPORT(retval, segClass, "Unable to determine segment class.");
+            }
+
+            if(0 == retval)
+            {
+                /*
+                **  Match any options required before continuing.
+                **  This is where you would want to add more restrictive totalling.
+                */
+
+                /*
+                **  Match size.
+                */
+                if(size < inOptions->mMinSize)
+                {
+                    continue;
+                }
+                if(size > inOptions->mMaxSize)
+                {
+                    continue;
+                }
+
+                /*
+                **  Match class.
+                */
+                if(0 != inOptions->mMatchClassCount)
+                {
+                    unsigned loop = 0;
+
+                    for(loop = 0; loop < inOptions->mMatchClassCount; loop++)
+                    {
+                        if(NULL != strstr(segClass, inOptions->mMatchClasses[loop]))
+                        {
+                            break;
+                        }
+                    }
+
+                    /*
+                    **  If there was no match, we skip the line.
+                    */
+                    if(loop == inOptions->mMatchClassCount)
+                    {
+                        continue;
+                    }
+                }
+
+                /*
+                **  Match scope.
+                */
+                if(0 != inOptions->mMatchScopeCount)
+                {
+                    unsigned loop = 0;
+
+                    for(loop = 0; loop < inOptions->mMatchScopeCount; loop++)
+                    {
+                        if(NULL != strstr(scope, inOptions->mMatchScopes[loop]))
+                        {
+                            break;
+                        }
+                    }
+
+                    /*
+                    **  If there was no match, we skip the line.
+                    */
+                    if(loop == inOptions->mMatchScopeCount)
+                    {
+                        continue;
+                    }
+                }
+
+                /*
+                **  Match modules.
+                */
+                if(0 != inOptions->mMatchModuleCount)
+                {
+                    unsigned loop = 0;
+
+                    for(loop = 0; loop < inOptions->mMatchModuleCount; loop++)
+                    {
+                        if(NULL != strstr(module, inOptions->mMatchModules[loop]))
+                        {
+                            break;
+                        }
+                    }
+
+                    /*
+                    **  If there was no match, we skip the line.
+                    */
+                    if(loop == inOptions->mMatchModuleCount)
+                    {
+                        continue;
+                    }
+                }
+
+                /*
+                **  Match sections.
+                */
+                if(0 != inOptions->mMatchSectionCount)
+                {
+                    unsigned loop = 0;
+
+                    for(loop = 0; loop < inOptions->mMatchSectionCount; loop++)
+                    {
+                        if(NULL != strstr(segment, inOptions->mMatchSections[loop]))
+                        {
+                            break;
+                        }
+                    }
+
+                    /*
+                    **  If there was no match, we skip the line.
+                    */
+                    if(loop == inOptions->mMatchSectionCount)
+                    {
+                        continue;
+                    }
+                }
+
+                /*
+                **  Match object.
+                */
+                if(0 != inOptions->mMatchObjectCount)
+                {
+                    unsigned loop = 0;
+
+                    for(loop = 0; loop < inOptions->mMatchObjectCount; loop++)
+                    {
+                        if(NULL != strstr(object, inOptions->mMatchObjects[loop]))
+                        {
+                            break;
+                        }
+                    }
+
+                    /*
+                    **  If there was no match, we skip the line.
+                    */
+                    if(loop == inOptions->mMatchObjectCount)
+                    {
+                        continue;
+                    }
+                }
+
+                /*
+                **  Match symbols.
+                */
+                if(0 != inOptions->mMatchSymbolCount)
+                {
+                    unsigned loop = 0;
+
+                    for(loop = 0; loop < inOptions->mMatchSymbolCount; loop++)
+                    {
+                        if(NULL != strstr(symbol, inOptions->mMatchSymbols[loop]))
+                        {
+                            break;
+                        }
+                    }
+
+                    /*
+                    **  If there was no match, we skip the line.
+                    */
+                    if(loop == inOptions->mMatchSymbolCount)
+                    {
+                        continue;
+                    }
+                }
+
+                /*
+                **  Update overall totals.
+                */
+                if(CODE == segmentClass)
+                {
+                    overall.mCode += size;
+                }
+                else if(DATA == segmentClass)
+                {
+                    overall.mData += size;
+                }
+
+                /*
+                **  See what else we should be tracking.
+                */
+                if(0 == inOptions->mTotalOnly)
+                {
+                    if(inOptions->mModules)
+                    {
+                        unsigned index = 0;
+                        
+                        /*
+                        **  Find the module to modify.
+                        */
+                        for(index = 0; index < moduleCount; index++)
+                        {
+                            if(0 == strcmp(modules[index].mModule, module))
+                            {
+                                break;
+                            }
+                        }
+                        
+                        /*
+                        **  If the index is the same as the count, we need to
+                        **      add a new module.
+                        */
+                        if(index == moduleCount)
+                        {
+                            void* moved = NULL;
+                            
+                            moved = realloc(modules, sizeof(ModuleStats) * (moduleCount + 1));
+                            if(NULL != moved)
+                            {
+                                modules = (ModuleStats*)moved;
+                                moduleCount++;
+                                
+                                memset(modules + index, 0, sizeof(ModuleStats));
+                                modules[index].mModule = strdup(module);
+                                if(NULL == modules[index].mModule)
+                                {
+                                    retval = __LINE__;
+                                    ERROR_REPORT(retval, module, "Unable to duplicate string.");
+                                }
+                            }
+                            else
+                            {
+                                retval = __LINE__;
+                                ERROR_REPORT(retval, inOptions->mProgramName, "Unable to allocate module memory.");
+                            }
+                        }
+                        
+                        if(0 == retval)
+                        {
+                            if(CODE == segmentClass)
+                            {
+                                modules[index].mSize.mCode += size;
+                            }
+                            else if(DATA == segmentClass)
+                            {
+                                modules[index].mSize.mData += size;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            retval = __LINE__;
+            ERROR_REPORT(retval, inOptions->mInputName, "Problem extracting values from file.");
+        }
+    }
+
+    if(0 == retval && 0 != ferror(inOptions->mInput))
+    {
+        retval = __LINE__;
+        ERROR_REPORT(retval, inOptions->mInputName, "Unable to read file.");
+    }
+
+    /*
+    **  If all went well, time to report.
+    */
+    if(0 == retval)
+    {
+        if(inOptions->mTotalOnly)
+        {
+            fprintf(inOptions->mOutput, "%u\n", (unsigned)(overall.mCode + overall.mData));
+        }
+        else
+        {
+            fprintf(inOptions->mOutput, "Overall Size\n");
+            fprintf(inOptions->mOutput, "\tTotal:\t%10u\n", (unsigned)(overall.mCode + overall.mData));
+            fprintf(inOptions->mOutput, "\tCode:\t%10u\n", (unsigned)overall.mCode);
+            fprintf(inOptions->mOutput, "\tData:\t%10u\n", (unsigned)overall.mData);
+        }
+
+        /*
+        **  Check options to see what else we should output.
+        */
+        if(inOptions->mModules && moduleCount)
+        {
+            unsigned loop = 0;
+
+            /*
+            **  Sort the modules by their size.
+            */
+            qsort(modules, (size_t)moduleCount, sizeof(ModuleStats), moduleCompare);
+
+            /*
+            **  Output each one.
+            **  Might as well clean up while we go too.
+            */
+            for(loop = 0; loop < moduleCount; loop++)
+            {
+                fprintf(inOptions->mOutput, "\n");
+                fprintf(inOptions->mOutput, "%s\n", modules[loop].mModule);
+                fprintf(inOptions->mOutput, "\tTotal:\t%10u\n", (unsigned)(modules[loop].mSize.mCode + modules[loop].mSize.mData));
+                fprintf(inOptions->mOutput, "\tCode:\t%10u\n", (unsigned)modules[loop].mSize.mCode);
+                fprintf(inOptions->mOutput, "\tData:\t%10u\n", (unsigned)modules[loop].mSize.mData);
+
+                CLEANUP(modules[loop].mModule);
+            }
+
+            /*
+            **  Done with modules.
+            */
+            CLEANUP(modules);
+            moduleCount = 0;
+        }
+    }
+
+    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");
+    outOptions->mMaxSize = 0xFFFFFFFFU;
+
+    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 == &gModuleSwitch)
+            {
+                outOptions->mModules = __LINE__;
+            }
+            else if(current == &gTotalSwitch)
+            {
+                outOptions->mTotalOnly = __LINE__;
+            }
+            else if(current == &gMinSize)
+            {
+                unsigned long arg = 0;
+                char* endScan = NULL;
+
+                errno = 0;
+                arg = strtoul(current->mValue, &endScan, 0);
+                if(0 == errno && endScan != current->mValue)
+                {
+                    outOptions->mMinSize = arg;
+                }
+                else
+                {
+                    retval = __LINE__;
+                    ERROR_REPORT(retval, current->mValue, "Unable to convert to a number.");
+                }
+            }
+            else if(current == &gMaxSize)
+            {
+                unsigned long arg = 0;
+                char* endScan = NULL;
+
+                errno = 0;
+                arg = strtoul(current->mValue, &endScan, 0);
+                if(0 == errno && endScan != current->mValue)
+                {
+                    outOptions->mMaxSize = arg;
+                }
+                else
+                {
+                    retval = __LINE__;
+                    ERROR_REPORT(retval, current->mValue, "Unable to convert to a number.");
+                }
+            }
+            else if(current == &gMatchClass)
+            {
+                char* dupMatch = NULL;
+                
+                dupMatch = strdup(current->mValue);
+                if(NULL != dupMatch)
+                {
+                    void* moved = NULL;
+
+                    moved = realloc(outOptions->mMatchClasses, sizeof(char*) * (outOptions->mMatchClassCount + 1));
+                    if(NULL != moved)
+                    {
+                        outOptions->mMatchClasses = (char**)moved;
+                        outOptions->mMatchClasses[outOptions->mMatchClassCount] = dupMatch;
+                        outOptions->mMatchClassCount++;
+                    }
+                    else
+                    {
+                        retval = __LINE__;
+                        ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
+                    }
+                }
+                else
+                {
+                    retval = __LINE__;
+                    ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
+                }
+            }
+            else if(current == &gMatchScope)
+            {
+                char* dupMatch = NULL;
+                
+                dupMatch = strdup(current->mValue);
+                if(NULL != dupMatch)
+                {
+                    void* moved = NULL;
+
+                    moved = realloc(outOptions->mMatchScopes, sizeof(char*) * (outOptions->mMatchScopeCount + 1));
+                    if(NULL != moved)
+                    {
+                        outOptions->mMatchScopes = (char**)moved;
+                        outOptions->mMatchScopes[outOptions->mMatchScopeCount] = dupMatch;
+                        outOptions->mMatchScopeCount++;
+                    }
+                    else
+                    {
+                        retval = __LINE__;
+                        ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
+                    }
+                }
+                else
+                {
+                    retval = __LINE__;
+                    ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
+                }
+            }
+            else if(current == &gMatchModule)
+            {
+                char* dupMatch = NULL;
+                
+                dupMatch = strdup(current->mValue);
+                if(NULL != dupMatch)
+                {
+                    void* moved = NULL;
+
+                    moved = realloc(outOptions->mMatchModules, sizeof(char*) * (outOptions->mMatchModuleCount + 1));
+                    if(NULL != moved)
+                    {
+                        outOptions->mMatchModules = (char**)moved;
+                        outOptions->mMatchModules[outOptions->mMatchModuleCount] = dupMatch;
+                        outOptions->mMatchModuleCount++;
+                    }
+                    else
+                    {
+                        retval = __LINE__;
+                        ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
+                    }
+                }
+                else
+                {
+                    retval = __LINE__;
+                    ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
+                }
+            }
+            else if(current == &gMatchSection)
+            {
+                char* dupMatch = NULL;
+                
+                dupMatch = strdup(current->mValue);
+                if(NULL != dupMatch)
+                {
+                    void* moved = NULL;
+
+                    moved = realloc(outOptions->mMatchSections, sizeof(char*) * (outOptions->mMatchSectionCount + 1));
+                    if(NULL != moved)
+                    {
+                        outOptions->mMatchSections = (char**)moved;
+                        outOptions->mMatchSections[outOptions->mMatchSectionCount] = dupMatch;
+                        outOptions->mMatchSectionCount++;
+                    }
+                    else
+                    {
+                        retval = __LINE__;
+                        ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
+                    }
+                }
+                else
+                {
+                    retval = __LINE__;
+                    ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
+                }
+            }
+            else if(current == &gMatchObject)
+            {
+                char* dupMatch = NULL;
+                
+                dupMatch = strdup(current->mValue);
+                if(NULL != dupMatch)
+                {
+                    void* moved = NULL;
+
+                    moved = realloc(outOptions->mMatchObjects, sizeof(char*) * (outOptions->mMatchObjectCount + 1));
+                    if(NULL != moved)
+                    {
+                        outOptions->mMatchObjects = (char**)moved;
+                        outOptions->mMatchObjects[outOptions->mMatchObjectCount] = dupMatch;
+                        outOptions->mMatchObjectCount++;
+                    }
+                    else
+                    {
+                        retval = __LINE__;
+                        ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
+                    }
+                }
+                else
+                {
+                    retval = __LINE__;
+                    ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
+                }
+            }
+            else if(current == &gMatchSymbol)
+            {
+                char* dupMatch = NULL;
+                
+                dupMatch = strdup(current->mValue);
+                if(NULL != dupMatch)
+                {
+                    void* moved = NULL;
+
+                    moved = realloc(outOptions->mMatchSymbols, sizeof(char*) * (outOptions->mMatchSymbolCount + 1));
+                    if(NULL != moved)
+                    {
+                        outOptions->mMatchSymbols = (char**)moved;
+                        outOptions->mMatchSymbols[outOptions->mMatchSymbolCount] = dupMatch;
+                        outOptions->mMatchSymbolCount++;
+                    }
+                    else
+                    {
+                        retval = __LINE__;
+                        ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
+                    }
+                }
+                else
+                {
+                    retval = __LINE__;
+                    ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
+                }
+            }
+            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.
+*/
+{
+    unsigned loop = 0;
+
+    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);
+    }
+
+    for(loop = 0; loop < inOptions->mMatchClassCount; loop++)
+    {
+        CLEANUP(inOptions->mMatchClasses[loop]);
+    }
+    CLEANUP(inOptions->mMatchClasses);
+
+    for(loop = 0; loop < inOptions->mMatchScopeCount; loop++)
+    {
+        CLEANUP(inOptions->mMatchScopes[loop]);
+    }
+    CLEANUP(inOptions->mMatchScopes);
+
+    for(loop = 0; loop < inOptions->mMatchModuleCount; loop++)
+    {
+        CLEANUP(inOptions->mMatchModules[loop]);
+    }
+    CLEANUP(inOptions->mMatchModules);
+
+    for(loop = 0; loop < inOptions->mMatchSectionCount; loop++)
+    {
+        CLEANUP(inOptions->mMatchSections[loop]);
+    }
+    CLEANUP(inOptions->mMatchSections);
+
+    for(loop = 0; loop < inOptions->mMatchObjectCount; loop++)
+    {
+        CLEANUP(inOptions->mMatchObjects[loop]);
+    }
+    CLEANUP(inOptions->mMatchObjects);
+
+    for(loop = 0; loop < inOptions->mMatchSymbolCount; loop++)
+    {
+        CLEANUP(inOptions->mMatchSymbols[loop]);
+    }
+    CLEANUP(inOptions->mMatchSymbols);
+
+    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 a tsv file and reports composite code and data sizes.\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 = codesighs(&options);
+    }
+
+    cleanOptions(&options);
+    return retval;
+}
+