src/third_party/codesighs/codesighs.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is codesighs.c code, released
  17  * Oct 3, 2002.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Netscape Communications Corporation.
  21  * Portions created by the Initial Developer are Copyright (C) 2002
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *   Garrett Arch Blythe, 03-October-2002
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <time.h>
  45 #include <ctype.h>
  46 #include <errno.h>
  47
  48 #define ERROR_REPORT(num, val, msg)   fprintf(stderr, "error(%d):\t\"%s\"\t%s\n", (num), (val), (msg));
  49 #define CLEANUP(ptr)    do { if(NULL != ptr) { free(ptr); ptr = NULL; } } while(0)
  50
  51
  52 typedef struct __struct_Options
  53 /*
  54 **  Options to control how we perform.
  55 **
  56 **  mProgramName    Used in help text.
  57 **  mInput          File to read for input.
  58 **                  Default is stdin.
  59 **  mInputName      Name of the file.
  60 **  mOutput         Output file, append.
  61 **                  Default is stdout.
  62 **  mOutputName     Name of the file.
  63 **  mHelp           Whether or not help should be shown.
  64 **  mModules        Output module by module information.
  65 **  mTotalOnly      Only output one number, the total.
  66 **  mMinSize        Ignore lines below this size.
  67 **  mMaxSize        Ignore lines above this size.
  68 **  mMatchScopes    For a line to be processed, it should match.
  69 **  mMachClasses    For a line to be processed, it should match.
  70 **  mMatchModules   For a line to be processed, it should match.
  71 **  mMatchSections  For a line to be processed, it should match.
  72 **  mMatchObjects   For a line to be processed, it should match.
  73 **  mMatchSymbols   For a line to be processed, it should match.
  74 */
  75 {
  76     const char* mProgramName;
  77     FILE* mInput;
  78     char* mInputName;
  79     FILE* mOutput;
  80     char* mOutputName;
  81     int mHelp;
  82     int mModules;
  83     int mTotalOnly;
  84     unsigned long mMinSize;
  85     unsigned long mMaxSize;
  86     char** mMatchScopes;
  87     unsigned mMatchScopeCount;
  88     char** mMatchClasses;
  89     unsigned mMatchClassCount;
  90     char** mMatchModules;
  91     unsigned mMatchModuleCount;
  92     char** mMatchSections;
  93     unsigned mMatchSectionCount;
  94     char** mMatchObjects;
  95     unsigned mMatchObjectCount;
  96     char** mMatchSymbols;
  97     unsigned mMatchSymbolCount;
  98 }
  99 Options;
 100
 101
 102 typedef struct __struct_Switch
 103 /*
 104 **  Command line options.
 105 */
 106 {
 107     const char* mLongName;
 108     const char* mShortName;
 109     int mHasValue;
 110     const char* mValue;
 111     const char* mDescription;
 112 }
 113 Switch;
 114
 115 #define DESC_NEWLINE "\n\t\t"
 116
 117 static Switch gInputSwitch = {"--input", "-i", 1, NULL, "Specify input file." DESC_NEWLINE "stdin is default."};
 118 static Switch gOutputSwitch = {"--output", "-o", 1, NULL, "Specify output file." DESC_NEWLINE "Appends if file exists." DESC_NEWLINE "stdout is default."};
 119 static Switch gHelpSwitch = {"--help", "-h", 0, NULL, "Information on usage."};
 120 static Switch gModuleSwitch = {"--modules", "-m", 0, NULL, "Output individual module numbers as well."};
 121 static Switch gTotalSwitch = {"--totalonly", "-t", 0, NULL, "Output only one number." DESC_NEWLINE "The total overall size." DESC_NEWLINE "Overrides other output options."};
 122 static Switch gMinSize = {"--min-size", "-min", 1, NULL, "Only consider symbols equal to or greater than this size." DESC_NEWLINE "The default is 0x00000000."};
 123 static Switch gMaxSize = {"--max-size", "-max", 1, NULL, "Only consider symbols equal to or smaller than this size." DESC_NEWLINE "The default is 0xFFFFFFFF."};
 124 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."};
 125 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."};
 126 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."};
 127 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."};
 128 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."};
 129 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."};
 130
 131 static Switch* gSwitches[] = {
 132         &gInputSwitch,
 133         &gOutputSwitch,
 134         &gModuleSwitch,
 135         &gTotalSwitch,
 136         &gMinSize,
 137         &gMaxSize,
 138         &gMatchClass,
 139         &gMatchScope,
 140         &gMatchModule,
 141         &gMatchSection,
 142         &gMatchObject,
 143         &gMatchSymbol,
 144         &gHelpSwitch
 145 };
 146
 147
 148 typedef struct __struct_SizeStats
 149 /*
 150 **  Track totals.
 151 **
 152 **  mData       Size of data.
 153 **  mCode       Size of code.
 154 */
 155 {
 156     unsigned long mData;
 157     unsigned long mCode;
 158 }
 159 SizeStats;
 160
 161
 162 typedef struct __struct_ModuleStats
 163 /*
 164 **  Track module level information.
 165 **
 166 **  mModule     Module name.
 167 **  mSize       Size of module.
 168 */
 169 {
 170     char* mModule;
 171     SizeStats mSize;
 172 }
 173 ModuleStats;
 174
 175 typedef enum __enum_SegmentClass
 176 {
 177         CODE,
 178         DATA
 179 }
 180 SegmentClass;
 181
 182
 183 static int moduleCompare(const void* in1, const void* in2)
 184 /*
 185 **  qsort helper function.
 186 */
 187 {
 188     int retval = 0;
 189
 190     const ModuleStats* one = (const ModuleStats*)in1;
 191     const ModuleStats* two = (const ModuleStats*)in2;
 192     unsigned long oneSize = one->mSize.mCode + one->mSize.mData;
 193     unsigned long twoSize = two->mSize.mCode + two->mSize.mData;
 194
 195     if(oneSize < twoSize)
 196     {
 197         retval = 1;
 198     }
 199     else if(oneSize > twoSize)
 200     {
 201         retval = -1;
 202     }
 203
 204     return retval;
 205 }
 206
 207
 208 void trimWhite(char* inString)
 209 /*
 210 **  Remove any whitespace from the end of the string.
 211 */
 212 {
 213     int len = strlen(inString);
 214
 215     while(len)
 216     {
 217         len--;
 218
 219         if(isspace(*(inString + len)))
 220         {
 221             *(inString + len) = '\0';
 222         }
 223         else
 224         {
 225             break;
 226         }
 227     }
 228 }
 229
 230
 231 int codesighs(Options* inOptions)
 232 /*
 233 **  Output a simplistic report based on our options.
 234 */
 235 {
 236     int retval = 0;
 237     char lineBuffer[0x1000];
 238     int scanRes = 0;
 239     unsigned long size;
 240     char segClass[0x10];
 241     char scope[0x10];
 242     char module[0x100];
 243     char segment[0x40];
 244     char object[0x100];
 245     char* symbol;
 246     SizeStats overall;
 247     ModuleStats* modules = NULL;
 248     unsigned moduleCount = 0;
 249
 250     memset(&overall, 0, sizeof(overall));
 251
 252     /*
 253     **  Read the file line by line, regardless of number of fields.
 254     **  We assume tab separated value formatting, at least 7 lead values:
 255     **      size class scope module segment object symbol ....
 256     */
 257     while(0 == retval && NULL != fgets(lineBuffer, sizeof(lineBuffer), inOptions->mInput))
 258     {
 259         trimWhite(lineBuffer);
 260
 261         scanRes = sscanf(lineBuffer,
 262             "%x\t%s\t%s\t%s\t%s\t%s\t",
 263             (unsigned*)&size,
 264             segClass,
 265             scope,
 266             module,
 267             segment,
 268             object);
 269
 270         if(6 == scanRes)
 271         {
 272             SegmentClass segmentClass = CODE;
 273
 274             symbol = strchr(lineBuffer, '\t') + 1;
 275
 276             /*
 277             **  Qualify the segment class.
 278             */
 279             if(0 == strcmp(segClass, "DATA"))
 280             {
 281                 segmentClass = DATA;
 282             }
 283             else if(0 == strcmp(segClass, "CODE"))
 284             {
 285                 segmentClass = CODE;
 286             }
 287             else
 288             {
 289                 retval = __LINE__;
 290                 ERROR_REPORT(retval, segClass, "Unable to determine segment class.");
 291             }
 292
 293             if(0 == retval)
 294             {
 295                 /*
 296                 **  Match any options required before continuing.
 297                 **  This is where you would want to add more restrictive totalling.
 298                 */
 299
 300                 /*
 301                 **  Match size.
 302                 */
 303                 if(size < inOptions->mMinSize)
 304                 {
 305                     continue;
 306                 }
 307                 if(size > inOptions->mMaxSize)
 308                 {
 309                     continue;
 310                 }
 311
 312                 /*
 313                 **  Match class.
 314                 */
 315                 if(0 != inOptions->mMatchClassCount)
 316                 {
 317                     unsigned loop = 0;
 318
 319                     for(loop = 0; loop < inOptions->mMatchClassCount; loop++)
 320                     {
 321                         if(NULL != strstr(segClass, inOptions->mMatchClasses[loop]))
 322                         {
 323                             break;
 324                         }
 325                     }
 326
 327                     /*
 328                     **  If there was no match, we skip the line.
 329                     */
 330                     if(loop == inOptions->mMatchClassCount)
 331                     {
 332                         continue;
 333                     }
 334                 }
 335
 336                 /*
 337                 **  Match scope.
 338                 */
 339                 if(0 != inOptions->mMatchScopeCount)
 340                 {
 341                     unsigned loop = 0;
 342
 343                     for(loop = 0; loop < inOptions->mMatchScopeCount; loop++)
 344                     {
 345                         if(NULL != strstr(scope, inOptions->mMatchScopes[loop]))
 346                         {
 347                             break;
 348                         }
 349                     }
 350
 351                     /*
 352                     **  If there was no match, we skip the line.
 353                     */
 354                     if(loop == inOptions->mMatchScopeCount)
 355                     {
 356                         continue;
 357                     }
 358                 }
 359
 360                 /*
 361                 **  Match modules.
 362                 */
 363                 if(0 != inOptions->mMatchModuleCount)
 364                 {
 365                     unsigned loop = 0;
 366
 367                     for(loop = 0; loop < inOptions->mMatchModuleCount; loop++)
 368                     {
 369                         if(NULL != strstr(module, inOptions->mMatchModules[loop]))
 370                         {
 371                             break;
 372                         }
 373                     }
 374
 375                     /*
 376                     **  If there was no match, we skip the line.
 377                     */
 378                     if(loop == inOptions->mMatchModuleCount)
 379                     {
 380                         continue;
 381                     }
 382                 }
 383
 384                 /*
 385                 **  Match sections.
 386                 */
 387                 if(0 != inOptions->mMatchSectionCount)
 388                 {
 389                     unsigned loop = 0;
 390
 391                     for(loop = 0; loop < inOptions->mMatchSectionCount; loop++)
 392                     {
 393                         if(NULL != strstr(segment, inOptions->mMatchSections[loop]))
 394                         {
 395                             break;
 396                         }
 397                     }
 398
 399                     /*
 400                     **  If there was no match, we skip the line.
 401                     */
 402                     if(loop == inOptions->mMatchSectionCount)
 403                     {
 404                         continue;
 405                     }
 406                 }
 407
 408                 /*
 409                 **  Match object.
 410                 */
 411                 if(0 != inOptions->mMatchObjectCount)
 412                 {
 413                     unsigned loop = 0;
 414
 415                     for(loop = 0; loop < inOptions->mMatchObjectCount; loop++)
 416                     {
 417                         if(NULL != strstr(object, inOptions->mMatchObjects[loop]))
 418                         {
 419                             break;
 420                         }
 421                     }
 422
 423                     /*
 424                     **  If there was no match, we skip the line.
 425                     */
 426                     if(loop == inOptions->mMatchObjectCount)
 427                     {
 428                         continue;
 429                     }
 430                 }
 431
 432                 /*
 433                 **  Match symbols.
 434                 */
 435                 if(0 != inOptions->mMatchSymbolCount)
 436                 {
 437                     unsigned loop = 0;
 438
 439                     for(loop = 0; loop < inOptions->mMatchSymbolCount; loop++)
 440                     {
 441                         if(NULL != strstr(symbol, inOptions->mMatchSymbols[loop]))
 442                         {
 443                             break;
 444                         }
 445                     }
 446
 447                     /*
 448                     **  If there was no match, we skip the line.
 449                     */
 450                     if(loop == inOptions->mMatchSymbolCount)
 451                     {
 452                         continue;
 453                     }
 454                 }
 455
 456                 /*
 457                 **  Update overall totals.
 458                 */
 459                 if(CODE == segmentClass)
 460                 {
 461                     overall.mCode += size;
 462                 }
 463                 else if(DATA == segmentClass)
 464                 {
 465                     overall.mData += size;
 466                 }
 467
 468                 /*
 469                 **  See what else we should be tracking.
 470                 */
 471                 if(0 == inOptions->mTotalOnly)
 472                 {
 473                     if(inOptions->mModules)
 474                     {
 475                         unsigned index = 0;
 476
 477                         /*
 478                         **  Find the module to modify.
 479                         */
 480                         for(index = 0; index < moduleCount; index++)
 481                         {
 482                             if(0 == strcmp(modules[index].mModule, module))
 483                             {
 484                                 break;
 485                             }
 486                         }
 487
 488                         /*
 489                         **  If the index is the same as the count, we need to
 490                         **      add a new module.
 491                         */
 492                         if(index == moduleCount)
 493                         {
 494                             void* moved = NULL;
 495
 496                             moved = realloc(modules, sizeof(ModuleStats) * (moduleCount + 1));
 497                             if(NULL != moved)
 498                             {
 499                                 modules = (ModuleStats*)moved;
 500                                 moduleCount++;
 501
 502                                 memset(modules + index, 0, sizeof(ModuleStats));
 503                                 modules[index].mModule = strdup(module);
 504                                 if(NULL == modules[index].mModule)
 505                                 {
 506                                     retval = __LINE__;
 507                                     ERROR_REPORT(retval, module, "Unable to duplicate string.");
 508                                 }
 509                             }
 510                             else
 511                             {
 512                                 retval = __LINE__;
 513                                 ERROR_REPORT(retval, inOptions->mProgramName, "Unable to allocate module memory.");
 514                             }
 515                         }
 516
 517                         if(0 == retval)
 518                         {
 519                             if(CODE == segmentClass)
 520                             {
 521                                 modules[index].mSize.mCode += size;
 522                             }
 523                             else if(DATA == segmentClass)
 524                             {
 525                                 modules[index].mSize.mData += size;
 526                             }
 527                         }
 528                     }
 529                 }
 530             }
 531         }
 532         else
 533         {
 534             retval = __LINE__;
 535             ERROR_REPORT(retval, inOptions->mInputName, "Problem extracting values from file.");
 536         }
 537     }
 538
 539     if(0 == retval && 0 != ferror(inOptions->mInput))
 540     {
 541         retval = __LINE__;
 542         ERROR_REPORT(retval, inOptions->mInputName, "Unable to read file.");
 543     }
 544
 545     /*
 546     **  If all went well, time to report.
 547     */
 548     if(0 == retval)
 549     {
 550         if(inOptions->mTotalOnly)
 551         {
 552             fprintf(inOptions->mOutput, "%u\n", (unsigned)(overall.mCode + overall.mData));
 553         }
 554         else
 555         {
 556             fprintf(inOptions->mOutput, "Overall Size\n");
 557             fprintf(inOptions->mOutput, "\tTotal:\t%10u\n", (unsigned)(overall.mCode + overall.mData));
 558             fprintf(inOptions->mOutput, "\tCode:\t%10u\n", (unsigned)overall.mCode);
 559             fprintf(inOptions->mOutput, "\tData:\t%10u\n", (unsigned)overall.mData);
 560         }
 561
 562         /*
 563         **  Check options to see what else we should output.
 564         */
 565         if(inOptions->mModules && moduleCount)
 566         {
 567             unsigned loop = 0;
 568
 569             /*
 570             **  Sort the modules by their size.
 571             */
 572             qsort(modules, (size_t)moduleCount, sizeof(ModuleStats), moduleCompare);
 573
 574             /*
 575             **  Output each one.
 576             **  Might as well clean up while we go too.
 577             */
 578             for(loop = 0; loop < moduleCount; loop++)
 579             {
 580                 fprintf(inOptions->mOutput, "\n");
 581                 fprintf(inOptions->mOutput, "%s\n", modules[loop].mModule);
 582                 fprintf(inOptions->mOutput, "\tTotal:\t%10u\n", (unsigned)(modules[loop].mSize.mCode + modules[loop].mSize.mData));
 583                 fprintf(inOptions->mOutput, "\tCode:\t%10u\n", (unsigned)modules[loop].mSize.mCode);
 584                 fprintf(inOptions->mOutput, "\tData:\t%10u\n", (unsigned)modules[loop].mSize.mData);
 585
 586                 CLEANUP(modules[loop].mModule);
 587             }
 588
 589             /*
 590             **  Done with modules.
 591             */
 592             CLEANUP(modules);
 593             moduleCount = 0;
 594         }
 595     }
 596
 597     return retval;
 598 }
 599
 600
 601 int initOptions(Options* outOptions, int inArgc, char** inArgv)
 602 /*
 603 **  returns int     0 if successful.
 604 */
 605 {
 606     int retval = 0;
 607     int loop = 0;
 608     int switchLoop = 0;
 609     int match = 0;
 610     const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]);
 611     Switch* current = NULL;
 612
 613     /*
 614     **  Set any defaults.
 615     */
 616     memset(outOptions, 0, sizeof(Options));
 617     outOptions->mProgramName = inArgv[0];
 618     outOptions->mInput = stdin;
 619     outOptions->mInputName = strdup("stdin");
 620     outOptions->mOutput = stdout;
 621     outOptions->mOutputName = strdup("stdout");
 622     outOptions->mMaxSize = 0xFFFFFFFFU;
 623
 624     if(NULL == outOptions->mOutputName || NULL == outOptions->mInputName)
 625     {
 626         retval = __LINE__;
 627         ERROR_REPORT(retval, "stdin/stdout", "Unable to strdup.");
 628     }
 629
 630     /*
 631     **  Go through and attempt to do the right thing.
 632     */
 633     for(loop = 1; loop < inArgc && 0 == retval; loop++)
 634     {
 635         match = 0;
 636         current = NULL;
 637
 638         for(switchLoop = 0; switchLoop < switchCount && 0 == retval; switchLoop++)
 639         {
 640             if(0 == strcmp(gSwitches[switchLoop]->mLongName, inArgv[loop]))
 641             {
 642                 match = __LINE__;
 643             }
 644             else if(0 == strcmp(gSwitches[switchLoop]->mShortName, inArgv[loop]))
 645             {
 646                 match = __LINE__;
 647             }
 648
 649             if(match)
 650             {
 651                 if(gSwitches[switchLoop]->mHasValue)
 652                 {
 653                     /*
 654                     **  Attempt to absorb next option to fullfill value.
 655                     */
 656                     if(loop + 1 < inArgc)
 657                     {
 658                         loop++;
 659
 660                         current = gSwitches[switchLoop];
 661                         current->mValue = inArgv[loop];
 662                     }
 663                 }
 664                 else
 665                 {
 666                     current = gSwitches[switchLoop];
 667                 }
 668
 669                 break;
 670             }
 671         }
 672
 673         if(0 == match)
 674         {
 675             outOptions->mHelp = __LINE__;
 676             retval = __LINE__;
 677             ERROR_REPORT(retval, inArgv[loop], "Unknown command line switch.");
 678         }
 679         else if(NULL == current)
 680         {
 681             outOptions->mHelp = __LINE__;
 682             retval = __LINE__;
 683             ERROR_REPORT(retval, inArgv[loop], "Command line switch requires a value.");
 684         }
 685         else
 686         {
 687             /*
 688             ** Do something based on address/swtich.
 689             */
 690             if(current == &gInputSwitch)
 691             {
 692                 CLEANUP(outOptions->mInputName);
 693                 if(NULL != outOptions->mInput && stdin != outOptions->mInput)
 694                 {
 695                     fclose(outOptions->mInput);
 696                     outOptions->mInput = NULL;
 697                 }
 698
 699                 outOptions->mInput = fopen(current->mValue, "r");
 700                 if(NULL == outOptions->mInput)
 701                 {
 702                     retval = __LINE__;
 703                     ERROR_REPORT(retval, current->mValue, "Unable to open input file.");
 704                 }
 705                 else
 706                 {
 707                     outOptions->mInputName = strdup(current->mValue);
 708                     if(NULL == outOptions->mInputName)
 709                     {
 710                         retval = __LINE__;
 711                         ERROR_REPORT(retval, current->mValue, "Unable to strdup.");
 712                     }
 713                 }
 714             }
 715             else if(current == &gOutputSwitch)
 716             {
 717                 CLEANUP(outOptions->mOutputName);
 718                 if(NULL != outOptions->mOutput && stdout != outOptions->mOutput)
 719                 {
 720                     fclose(outOptions->mOutput);
 721                     outOptions->mOutput = NULL;
 722                 }
 723
 724                 outOptions->mOutput = fopen(current->mValue, "a");
 725                 if(NULL == outOptions->mOutput)
 726                 {
 727                     retval = __LINE__;
 728                     ERROR_REPORT(retval, current->mValue, "Unable to open output file.");
 729                 }
 730                 else
 731                 {
 732                     outOptions->mOutputName = strdup(current->mValue);
 733                     if(NULL == outOptions->mOutputName)
 734                     {
 735                         retval = __LINE__;
 736                         ERROR_REPORT(retval, current->mValue, "Unable to strdup.");
 737                     }
 738                 }
 739             }
 740             else if(current == &gHelpSwitch)
 741             {
 742                 outOptions->mHelp = __LINE__;
 743             }
 744             else if(current == &gModuleSwitch)
 745             {
 746                 outOptions->mModules = __LINE__;
 747             }
 748             else if(current == &gTotalSwitch)
 749             {
 750                 outOptions->mTotalOnly = __LINE__;
 751             }
 752             else if(current == &gMinSize)
 753             {
 754                 unsigned long arg = 0;
 755                 char* endScan = NULL;
 756
 757                 errno = 0;
 758                 arg = strtoul(current->mValue, &endScan, 0);
 759                 if(0 == errno && endScan != current->mValue)
 760                 {
 761                     outOptions->mMinSize = arg;
 762                 }
 763                 else
 764                 {
 765                     retval = __LINE__;
 766                     ERROR_REPORT(retval, current->mValue, "Unable to convert to a number.");
 767                 }
 768             }
 769             else if(current == &gMaxSize)
 770             {
 771                 unsigned long arg = 0;
 772                 char* endScan = NULL;
 773
 774                 errno = 0;
 775                 arg = strtoul(current->mValue, &endScan, 0);
 776                 if(0 == errno && endScan != current->mValue)
 777                 {
 778                     outOptions->mMaxSize = arg;
 779                 }
 780                 else
 781                 {
 782                     retval = __LINE__;
 783                     ERROR_REPORT(retval, current->mValue, "Unable to convert to a number.");
 784                 }
 785             }
 786             else if(current == &gMatchClass)
 787             {
 788                 char* dupMatch = NULL;
 789
 790                 dupMatch = strdup(current->mValue);
 791                 if(NULL != dupMatch)
 792                 {
 793                     void* moved = NULL;
 794
 795                     moved = realloc(outOptions->mMatchClasses, sizeof(char*) * (outOptions->mMatchClassCount + 1));
 796                     if(NULL != moved)
 797                     {
 798                         outOptions->mMatchClasses = (char**)moved;
 799                         outOptions->mMatchClasses[outOptions->mMatchClassCount] = dupMatch;
 800                         outOptions->mMatchClassCount++;
 801                     }
 802                     else
 803                     {
 804                         retval = __LINE__;
 805                         ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
 806                     }
 807                 }
 808                 else
 809                 {
 810                     retval = __LINE__;
 811                     ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
 812                 }
 813             }
 814             else if(current == &gMatchScope)
 815             {
 816                 char* dupMatch = NULL;
 817
 818                 dupMatch = strdup(current->mValue);
 819                 if(NULL != dupMatch)
 820                 {
 821                     void* moved = NULL;
 822
 823                     moved = realloc(outOptions->mMatchScopes, sizeof(char*) * (outOptions->mMatchScopeCount + 1));
 824                     if(NULL != moved)
 825                     {
 826                         outOptions->mMatchScopes = (char**)moved;
 827                         outOptions->mMatchScopes[outOptions->mMatchScopeCount] = dupMatch;
 828                         outOptions->mMatchScopeCount++;
 829                     }
 830                     else
 831                     {
 832                         retval = __LINE__;
 833                         ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
 834                     }
 835                 }
 836                 else
 837                 {
 838                     retval = __LINE__;
 839                     ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
 840                 }
 841             }
 842             else if(current == &gMatchModule)
 843             {
 844                 char* dupMatch = NULL;
 845
 846                 dupMatch = strdup(current->mValue);
 847                 if(NULL != dupMatch)
 848                 {
 849                     void* moved = NULL;
 850
 851                     moved = realloc(outOptions->mMatchModules, sizeof(char*) * (outOptions->mMatchModuleCount + 1));
 852                     if(NULL != moved)
 853                     {
 854                         outOptions->mMatchModules = (char**)moved;
 855                         outOptions->mMatchModules[outOptions->mMatchModuleCount] = dupMatch;
 856                         outOptions->mMatchModuleCount++;
 857                     }
 858                     else
 859                     {
 860                         retval = __LINE__;
 861                         ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
 862                     }
 863                 }
 864                 else
 865                 {
 866                     retval = __LINE__;
 867                     ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
 868                 }
 869             }
 870             else if(current == &gMatchSection)
 871             {
 872                 char* dupMatch = NULL;
 873
 874                 dupMatch = strdup(current->mValue);
 875                 if(NULL != dupMatch)
 876                 {
 877                     void* moved = NULL;
 878
 879                     moved = realloc(outOptions->mMatchSections, sizeof(char*) * (outOptions->mMatchSectionCount + 1));
 880                     if(NULL != moved)
 881                     {
 882                         outOptions->mMatchSections = (char**)moved;
 883                         outOptions->mMatchSections[outOptions->mMatchSectionCount] = dupMatch;
 884                         outOptions->mMatchSectionCount++;
 885                     }
 886                     else
 887                     {
 888                         retval = __LINE__;
 889                         ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
 890                     }
 891                 }
 892                 else
 893                 {
 894                     retval = __LINE__;
 895                     ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
 896                 }
 897             }
 898             else if(current == &gMatchObject)
 899             {
 900                 char* dupMatch = NULL;
 901
 902                 dupMatch = strdup(current->mValue);
 903                 if(NULL != dupMatch)
 904                 {
 905                     void* moved = NULL;
 906
 907                     moved = realloc(outOptions->mMatchObjects, sizeof(char*) * (outOptions->mMatchObjectCount + 1));
 908                     if(NULL != moved)
 909                     {
 910                         outOptions->mMatchObjects = (char**)moved;
 911                         outOptions->mMatchObjects[outOptions->mMatchObjectCount] = dupMatch;
 912                         outOptions->mMatchObjectCount++;
 913                     }
 914                     else
 915                     {
 916                         retval = __LINE__;
 917                         ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
 918                     }
 919                 }
 920                 else
 921                 {
 922                     retval = __LINE__;
 923                     ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
 924                 }
 925             }
 926             else if(current == &gMatchSymbol)
 927             {
 928                 char* dupMatch = NULL;
 929
 930                 dupMatch = strdup(current->mValue);
 931                 if(NULL != dupMatch)
 932                 {
 933                     void* moved = NULL;
 934
 935                     moved = realloc(outOptions->mMatchSymbols, sizeof(char*) * (outOptions->mMatchSymbolCount + 1));
 936                     if(NULL != moved)
 937                     {
 938                         outOptions->mMatchSymbols = (char**)moved;
 939                         outOptions->mMatchSymbols[outOptions->mMatchSymbolCount] = dupMatch;
 940                         outOptions->mMatchSymbolCount++;
 941                     }
 942                     else
 943                     {
 944                         retval = __LINE__;
 945                         ERROR_REPORT(retval, current->mLongName, "Unable to expand array.");
 946                     }
 947                 }
 948                 else
 949                 {
 950                     retval = __LINE__;
 951                     ERROR_REPORT(retval, current->mValue, "Unable to duplicate string.");
 952                 }
 953             }
 954             else
 955             {
 956                 retval = __LINE__;
 957                 ERROR_REPORT(retval, current->mLongName, "No handler for command line switch.");
 958             }
 959         }
 960     }
 961
 962     return retval;
 963 }
 964
 965
 966 void cleanOptions(Options* inOptions)
 967 /*
 968 **  Clean up any open handles.
 969 */
 970 {
 971     unsigned loop = 0;
 972
 973     CLEANUP(inOptions->mInputName);
 974     if(NULL != inOptions->mInput && stdin != inOptions->mInput)
 975     {
 976         fclose(inOptions->mInput);
 977     }
 978     CLEANUP(inOptions->mOutputName);
 979     if(NULL != inOptions->mOutput && stdout != inOptions->mOutput)
 980     {
 981         fclose(inOptions->mOutput);
 982     }
 983
 984     for(loop = 0; loop < inOptions->mMatchClassCount; loop++)
 985     {
 986         CLEANUP(inOptions->mMatchClasses[loop]);
 987     }
 988     CLEANUP(inOptions->mMatchClasses);
 989
 990     for(loop = 0; loop < inOptions->mMatchScopeCount; loop++)
 991     {
 992         CLEANUP(inOptions->mMatchScopes[loop]);
 993     }
 994     CLEANUP(inOptions->mMatchScopes);
 995
 996     for(loop = 0; loop < inOptions->mMatchModuleCount; loop++)
 997     {
 998         CLEANUP(inOptions->mMatchModules[loop]);
 999     }
1000     CLEANUP(inOptions->mMatchModules);
1001
1002     for(loop = 0; loop < inOptions->mMatchSectionCount; loop++)
1003     {
1004         CLEANUP(inOptions->mMatchSections[loop]);
1005     }
1006     CLEANUP(inOptions->mMatchSections);
1007
1008     for(loop = 0; loop < inOptions->mMatchObjectCount; loop++)
1009     {
1010         CLEANUP(inOptions->mMatchObjects[loop]);
1011     }
1012     CLEANUP(inOptions->mMatchObjects);
1013
1014     for(loop = 0; loop < inOptions->mMatchSymbolCount; loop++)
1015     {
1016         CLEANUP(inOptions->mMatchSymbols[loop]);
1017     }
1018     CLEANUP(inOptions->mMatchSymbols);
1019
1020     memset(inOptions, 0, sizeof(Options));
1021 }
1022
1023
1024 void showHelp(Options* inOptions)
1025 /*
1026 **  Show some simple help text on usage.
1027 */
1028 {
1029     int loop = 0;
1030     const int switchCount = sizeof(gSwitches) / sizeof(gSwitches[0]);
1031     const char* valueText = NULL;
1032
1033     printf("usage:\t%s [arguments]\n", inOptions->mProgramName);
1034     printf("\n");
1035     printf("arguments:\n");
1036
1037     for(loop = 0; loop < switchCount; loop++)
1038     {
1039         if(gSwitches[loop]->mHasValue)
1040         {
1041             valueText = " <value>";
1042         }
1043         else
1044         {
1045             valueText = "";
1046         }
1047
1048         printf("\t%s%s\n", gSwitches[loop]->mLongName, valueText);
1049         printf("\t %s%s", gSwitches[loop]->mShortName, valueText);
1050         printf(DESC_NEWLINE "%s\n\n", gSwitches[loop]->mDescription);
1051     }
1052
1053     printf("This tool takes a tsv file and reports composite code and data sizes.\n");
1054 }
1055
1056
1057 int main(int inArgc, char** inArgv)
1058 {
1059     int retval = 0;
1060     Options options;
1061
1062     retval = initOptions(&options, inArgc, inArgv);
1063     if(options.mHelp)
1064     {
1065         showHelp(&options);
1066     }
1067     else if(0 == retval)
1068     {
1069         retval = codesighs(&options);
1070     }
1071
1072     cleanOptions(&options);
1073     return retval;
1074 }
1075