config/makedep.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either of the GNU General Public License Version 2 or later (the "GPL"),
  26  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 // Dependency building hack
  39 //
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <sys/stat.h>
  44 #include <ctype.h>
  45 #include <afxcoll.h>
  46 #include <afxtempl.h>
  47
  48 int mainReturn = 0;
  49 BOOL b16 = FALSE;
  50 BOOL bSimple = FALSE;
  51
  52 //      freopen won't work on stdout in win16
  53 FILE *pAltFile = stdout;
  54
  55 CStringArray includeDirectories;
  56
  57 // turn a file, relative path or other into an absolute path
  58 // This function copied from MFC 1.52
  59 BOOL PASCAL _AfxFullPath(LPSTR lpszPathOut, LPCSTR lpszFileIn)
  60         // lpszPathOut = buffer of _MAX_PATH
  61         // lpszFileIn = file, relative path or absolute path
  62         // (both in ANSI character set)
  63 {
  64         OFSTRUCT of;
  65         if (OpenFile(lpszFileIn, &of, OF_PARSE) != HFILE_ERROR)
  66         {
  67                 // of.szPathName is in the OEM character set
  68                 OemToAnsi(of.szPathName, lpszPathOut);
  69                 AnsiUpper(lpszPathOut); // paths in upper case just to be sure
  70                 return TRUE;
  71         }
  72         else
  73         {
  74                 TRACE1("Warning: could not parse the path %Fs\n", lpszFileIn);
  75                 lstrcpy(lpszPathOut, lpszFileIn);  // take it literally
  76                 AnsiUpper(lpszPathOut); // paths in upper case just to be sure
  77                 return FALSE;
  78         }
  79 }
  80
  81 void AddIncludeDirectory( char *pString ){
  82     CString s = pString;
  83         int len = s.GetLength();
  84     if(len > 0 && s[len - 1] != '\\' ){
  85         s += "\\";
  86     }
  87     includeDirectories.Add(s);
  88 }
  89
  90 BOOL FileExists( const char *pString ){
  91     struct _stat buf;
  92     int result;
  93
  94     result = _stat( pString, &buf );
  95     return (result == 0);
  96 }
  97
  98 void FixPathName(CString& str) {
  99         str.MakeUpper();                // all upper case
 100
 101         // now switch all forward slashes to back slashes
 102         int index;
 103         while ((index = str.Find('/')) != -1) {
 104                 str.SetAt(index, '\\');
 105         }
 106 }
 107
 108 void FATName(CString& csLONGName)
 109 {
 110     //  Only relevant for 16 bits.
 111     if(b16) {
 112         //  Convert filename to FAT (8.3) equivalent.
 113         char aBuffer[2048];
 114
 115         if(GetShortPathName(csLONGName, aBuffer, 2048)) {
 116             csLONGName = aBuffer;
 117         }
 118     }
 119 }
 120
 121
 122 class CFileRecord {
 123 public:
 124     CString m_shortName;
 125     CString m_pathName;
 126     CPtrArray m_includes;  // pointers to CFileRecords in fileMap
 127     BOOL m_bVisited;
 128     BOOL m_bSystem;
 129     BOOL m_bSource;
 130     static CMapStringToPtr fileMap;      // contains all allocated CFileRecords
 131     static CStringArray orderedFileNames;
 132     static CMapStringToPtr includeMap;   // pointer to CFileRecords in fileMap
 133     static CMapStringToPtr noDependMap;
 134
 135     CFileRecord( const char *shortName, const char* pFullName, BOOL bSystem, BOOL bSource):
 136                 m_shortName( shortName ),
 137                 m_pathName(),
 138                 m_includes(),
 139                 m_bVisited(FALSE),
 140                 m_bSource( bSource ),
 141                 m_bSystem(bSystem){
 142
 143                 m_pathName = pFullName;
 144                 FixPathName(m_pathName);                                // all upper case for consistency
 145                 ASSERT(FindFileRecord(m_pathName) == NULL);     // make sure it's not already in the map
 146         fileMap[m_pathName] = this;                     // add this to the filemap, using the appropriate name as the key
 147                 if (bSource) {
 148                         orderedFileNames.Add(m_pathName);       // remember the order we saw source files in
 149                 }
 150     }
 151
 152     //
 153     // open the file and grab all the includes.
 154     //
 155     void ProcessFile(){
 156         FILE *f;
 157                 CString fullName;
 158         BOOL bSystem;
 159                 DWORD lineCntr = 0;
 160                 char *a = new char[2048];
 161         memset(a, 0, 2048);
 162                 char srcPath[_MAX_PATH];
 163
 164                 // construct the full path
 165                 if (!_AfxFullPath(srcPath, m_pathName)) {
 166                         strcpy(srcPath, m_pathName);
 167                 }
 168
 169                 // strip off the source filename to end up with just the path
 170                 LPSTR pTemp = strrchr(srcPath, '\\');
 171                 if (pTemp) {
 172                         *(pTemp + 1) = 0;
 173                 }
 174
 175         f = fopen(m_pathName, "r");
 176         if(f != NULL && f != (FILE *)-1)  {
 177                         setvbuf(f, NULL, _IOFBF, 32768);                // use a large file buffer
 178             while(fgets(a, 2047, f)) {
 179                                 // if the string "//{{NO_DEPENDENCIES}}" is at the start of one of the
 180                                 // first 10 lines of a file, don't build dependencies on it or any
 181                                 // of the files it includes
 182                                 if (lineCntr < 10) {
 183                                         static char* pDependStr = "//{{NO_DEPENDENCIES}}";
 184                                         if (strncmp(a, pDependStr, strlen(pDependStr)) == 0) {
 185                                                 noDependMap[m_pathName] = 0;    // add it to the noDependMap
 186                                                 break;                                                  // no need for further processing of this file
 187                                         }
 188                                 }
 189                                 ++lineCntr;
 190                                 // have to handle a variety of legal syntaxes that we find in our source files:
 191                                 //    #include
 192                                 // #   include
 193                 // #include
 194                                 // if the first non-whitespace char is a '#', consider this line
 195                                 pTemp = a;
 196                                 pTemp += strspn(pTemp, " \t");                  // skip whitespace
 197                                 if (*pTemp == '#') {
 198                                         ++pTemp;                                                        // skip the '#'
 199                                         pTemp += strspn(pTemp, " \t");          // skip more whitespace
 200                                         if( !strncmp(pTemp, "include", 7) ){
 201                                                 pTemp += 7;                                             // skip the "include"
 202                                                 pTemp += strspn(pTemp, " \t");  // skip more whitespace
 203                                                 bSystem = (*pTemp == '<');              // mark if it's a system include or not
 204                         // forget system files -- we just have to search all the paths
 205                         // every time and never find them! This change alone speeds a full
 206                         // depend run on my system from 5 minutes to 3:15
 207                                                 // if (bSystem || (*pTemp == '"')) {
 208                         if (*pTemp == '"') {
 209                                                         LPSTR pStart = pTemp + 1;       // mark the start of the string
 210                                                         pTemp = pStart + strcspn(pStart, ">\" ");       // find the end of the string
 211                                                         *pTemp = 0;                                     // terminate the string
 212
 213                                                         // construct the full pathname from the path part of the
 214                                                         // source file and the name listed here
 215                                                         fullName = srcPath;
 216                                                         fullName += pStart;
 217                                                         CFileRecord *pAddMe = AddFile( pStart, fullName, bSystem );
 218                                                         if (pAddMe) {
 219                                                                 m_includes.Add(pAddMe);
 220                                                         }
 221                                                 }
 222                                         }
 223                                 }
 224             }
 225             fclose(f);
 226         }
 227         delete [] a;
 228     }
 229
 230     void PrintIncludes(){
 231         int i = 0;
 232         while( i < m_includes.GetSize() ){
 233             CFileRecord *pRec = (CFileRecord*) m_includes[i];
 234
 235             //  Don't write out files that don't exist or are not in the namespace
 236             //      of the programs using it (netscape_AppletMozillaContext.h doesn't
 237             //      mix well with 16 bits).
 238                         // Also don't write out files that are in the noDependMap
 239                         void*   lookupJunk;
 240             if( !pRec->m_bVisited && pRec->m_pathName.GetLength() != 0 && !noDependMap.Lookup(pRec->m_pathName, lookupJunk)) {
 241
 242                                 // not supposed to have a file in the list that doesn't exist
 243                                 ASSERT(FileExists(pRec->m_pathName));
 244
 245                 CString csOutput;
 246                 csOutput = pRec->m_pathName;
 247                 FATName(csOutput);
 248
 249                                 fprintf(pAltFile, "\\\n    %s ", (const char *) csOutput );
 250
 251                                 // mark this one as done so we don't do it more than once
 252                 pRec->m_bVisited = TRUE;
 253
 254                 pRec->PrintIncludes();
 255             }
 256             i++;
 257         }
 258     }
 259
 260     void PrintDepend(){
 261         CFileRecord *pRec;
 262         BOOL bFound;
 263         POSITION next;
 264         CString name;
 265
 266                 // clear all the m_bVisisted flags so we can use it to keep track
 267                 // of whether we've already output this file as a dependency
 268         next = fileMap.GetStartPosition();
 269         while( next ){
 270             fileMap.GetNextAssoc( next, name, *(void**)&pRec );
 271             pRec->m_bVisited = FALSE;
 272         }
 273
 274         char fname[_MAX_FNAME];
 275
 276                 if (pRec->m_pathName.GetLength() != 0) {
 277             if( bSimple ){
 278                         fprintf(pAltFile, "\n\n\n%s:\t", m_pathName );
 279             }
 280             else {
 281                 CString csOutput;
 282                 csOutput = m_pathName;
 283                 FATName(csOutput);
 284
 285                         _splitpath( csOutput, NULL, NULL, fname, NULL );
 286
 287                         fprintf(pAltFile, "\n\n\n$(OUTDIR)\\%s.obj: %s ", fname, (const char*) csOutput );
 288             }
 289                 m_bVisited = TRUE;              // mark it as done so we won't do it again
 290                 PrintIncludes();
 291                 }
 292     }
 293
 294
 295     static CString NormalizeFileName( const char* pName ){
 296         return CString(pName);
 297     }
 298
 299     static CFileRecord* FindFileRecord( const char *pName ){
 300                 CFileRecord* pRec = NULL;
 301                 CString name(pName);
 302                 FixPathName(name);
 303                 fileMap.Lookup(name, (void*&)pRec);
 304                 return(pRec);
 305     }
 306 public:
 307     static CFileRecord* AddFile( const char* pShortName, const char* pFullName, BOOL bSystem = FALSE,
 308                 BOOL bSource = FALSE ){
 309
 310                 char fullName[_MAX_PATH];
 311                 BOOL bFound = FALSE;
 312                 CString foundName;
 313                 CString fixedShortName;
 314         CString s;
 315
 316         // normalize the name
 317         fixedShortName = pShortName;
 318         FixPathName(fixedShortName);
 319         pShortName = fixedShortName;
 320
 321         // if it is source, we might be getting an obj file.  If we do,
 322         //  convert it to a c or c++ file.
 323         if( bSource && (strcmp(GetExt(pShortName),".obj") == 0) ){
 324             char path_buffer[_MAX_PATH];
 325             char fname[_MAX_FNAME] = "";
 326             CString s;
 327
 328             _splitpath( pShortName, NULL, NULL, fname, NULL );
 329             if( FileExists( s = CString(fname) + ".cpp") ){
 330                 pShortName = s;
 331                 pFullName = s;
 332             }
 333             else if( FileExists( s = CString(fname) + ".c" ) ){
 334                 pShortName = s;
 335                 pFullName = s;
 336             }
 337             else {
 338                 return 0;
 339             }
 340         }
 341
 342                 // if pFullName was not constructed, construct it here based on the current directory
 343                 if (!pFullName) {
 344                         _AfxFullPath(fullName, pShortName);
 345                         pFullName = fullName;
 346                 }
 347
 348                 // first check to see if we already have this exact file
 349                 CFileRecord *pRec = FindFileRecord(pFullName);
 350
 351         // if not found and not a source file check the header list --
 352         // all files we've found in include directories are in the includeMap.
 353         // we can save gobs of time by getting it from there
 354         if (!pRec && !bSource)
 355             includeMap.Lookup(fixedShortName, (void*&)pRec);
 356
 357         if (!pRec) {
 358             // not in one of our lists, start scrounging on disk
 359
 360             // check the fullname first
 361             if (FileExists(pFullName)) {
 362                 foundName = pFullName;
 363                 bFound = TRUE;
 364             }
 365             else {
 366                 // if still not found, search the include paths
 367                 int i = 0;
 368                 while( i < includeDirectories.GetSize() ){
 369                     if( FileExists( includeDirectories[i] + pShortName ) ){
 370                         foundName = includeDirectories[i] + pShortName;
 371                         bFound = TRUE;
 372                         break;
 373                     }
 374                     i++;
 375                 }
 376             }
 377         }
 378         else {
 379             // we found it
 380             bFound = TRUE;
 381         }
 382
 383                 // source files are not allowed to be missing
 384                 if (bSource && !pRec && !bFound) {
 385                         fprintf(stderr, "Source file: %s doesn't exist\n", pFullName);
 386                         mainReturn = -1;                // exit with an error, don't write out the results
 387                 }
 388
 389 #ifdef _DEBUG
 390                 if (!pRec && !bFound && !bSystem) {
 391                         fprintf(stderr, "Header not found: %s (%s)\n", pShortName, pFullName);
 392                 }
 393 #endif
 394
 395                 // if none of the above logic found it already in the list,
 396         // must be a new file, add it to the list
 397         if (bFound && (pRec == NULL)) {
 398             pRec = new CFileRecord( pShortName, foundName, bSystem, bSource);
 399
 400                         // if this one isn't a source file add it to the includeMap
 401                         // for performance reasons (so we can find it there next time rather
 402                         // than having to search the file system again)
 403                         if (!bSource) {
 404                                 includeMap[pShortName] = pRec;
 405                         }
 406         }
 407         return pRec;
 408     }
 409
 410
 411     static void PrintDependancies(){
 412         CFileRecord *pRec;
 413         BOOL bFound;
 414         POSITION next;
 415         CString name;
 416
 417                 // use orderedFileNames to preserve order
 418                 for (int pos = 0; pos < orderedFileNames.GetSize(); pos++) {
 419                         pRec = FindFileRecord(orderedFileNames[pos]);
 420             if(pRec && pRec->m_bSource ){
 421                 pRec->PrintDepend();
 422                         }
 423                 }
 424     }
 425
 426
 427     void PrintDepend2(){
 428         CFileRecord *pRec;
 429         int i;
 430
 431         if( m_includes.GetSize() != 0 ){
 432                         fprintf(pAltFile, "\n\n\n%s: \\\n",m_pathName );
 433             i = 0;
 434             while( i < m_includes.GetSize() ){
 435                 pRec = (CFileRecord*) m_includes[i];
 436                         fprintf(pAltFile, "\t\t\t%s\t\\\n",pRec->m_pathName );
 437                 i++;
 438             }
 439         }
 440     }
 441
 442     static void PrintDependancies2(){
 443         CFileRecord *pRec;
 444         BOOL bFound;
 445         POSITION next;
 446         CString name;
 447
 448         next = fileMap.GetStartPosition();
 449         while( next ){
 450             fileMap.GetNextAssoc( next, name, *(void**)&pRec );
 451             pRec->PrintDepend2();
 452         }
 453     }
 454
 455
 456     static void PrintTargets(const char *pMacroName, const char *pDelimiter){
 457         CFileRecord *pRec;
 458         BOOL bFound;
 459         POSITION next;
 460         CString name;
 461
 462         BOOL bNeedDelimiter = FALSE;
 463                 fprintf(pAltFile, "%s = ", pMacroName);
 464
 465                 // use orderedFileNames to preserve target order
 466                 for (int pos = 0; pos < orderedFileNames.GetSize(); pos++) {
 467                         pRec = FindFileRecord(orderedFileNames[pos]);
 468                         ASSERT(pRec);
 469
 470             if( pRec && pRec->m_bSource && pRec->m_pathName.GetLength() != 0){
 471                 char fname[_MAX_FNAME];
 472
 473                 CString csOutput;
 474                 csOutput = pRec->m_pathName;
 475                 FATName(csOutput);
 476
 477                 _splitpath( csOutput, NULL, NULL, fname, NULL );
 478
 479                 if(bNeedDelimiter)  {
 480                     fprintf(pAltFile, "%s\n", pDelimiter);
 481                     bNeedDelimiter = FALSE;
 482                 }
 483
 484                                 fprintf(pAltFile, "     $(OUTDIR)\\%s.obj   ", fname );
 485                 bNeedDelimiter = TRUE;
 486             }
 487         }
 488                 fprintf(pAltFile, "\n\n\n");
 489     }
 490
 491     static CString DirDefine( const char *pPath ){
 492         char path_buffer[_MAX_PATH];
 493         char dir[_MAX_DIR] = "";
 494         char dir2[_MAX_DIR] = "";
 495         char fname[_MAX_FNAME] = "";
 496         char ext[_MAX_EXT] = "";
 497         CString s;
 498
 499         _splitpath( pPath, 0, dir, 0, ext );
 500
 501         BOOL bDone = FALSE;
 502
 503         while( dir && !bDone){
 504             // remove the trailing slash
 505             dir[ strlen(dir)-1] = 0;
 506             _splitpath( dir, 0, dir2, fname, 0 );
 507             if( strcmp( fname, "SRC" ) == 0 ){
 508                 strcpy( dir, dir2 );
 509             }
 510             else {
 511                 bDone = TRUE;
 512             }
 513         }
 514         s = CString(fname) + "_" + (ext+1);
 515         return s;
 516     }
 517
 518
 519     static void PrintSources(){
 520         int i;
 521         CString dirName, newDirName;
 522
 523         for( i=0; i< orderedFileNames.GetSize(); i++ ){
 524             newDirName= DirDefine( orderedFileNames[i] );
 525             if( newDirName != dirName ){
 526                 fprintf( pAltFile, "\n\n\nFILES_%s= $(FILES_%s) \\",
 527                         (const char*)newDirName, (const char*)newDirName );
 528                 dirName = newDirName;
 529             }
 530             fprintf( pAltFile, "\n\t%s^", (const char*)orderedFileNames[i] );
 531         }
 532     }
 533
 534     static CString SourceDirName( const char *pPath, BOOL bFileName){
 535         char path_buffer[_MAX_PATH];
 536         char drive[_MAX_DRIVE] = "";
 537         char dir[_MAX_DIR] = "";
 538         char fname[_MAX_FNAME] = "";
 539         char ext[_MAX_EXT] = "";
 540         CString s;
 541
 542         _splitpath( pPath, drive, dir, fname, ext );
 543
 544         s = CString(drive) + dir;
 545         if( bFileName ){
 546             s += CString("FNAME") + ext;
 547         }
 548         else {
 549             // remove the trailing slash
 550             s = s.Left( s.GetLength() - 1 );
 551         }
 552         return s;
 553     }
 554
 555
 556     static CString GetExt( const char *pPath){
 557         char ext[_MAX_EXT] = "";
 558
 559         _splitpath( pPath, 0,0,0, ext );
 560
 561         CString s = CString(ext);
 562         s.MakeLower();
 563         return s;
 564     }
 565
 566     static void PrintBuildRules(){
 567         int i;
 568         CString dirName;
 569
 570         CMapStringToPtr dirList;
 571
 572         for( i=0; i< orderedFileNames.GetSize(); i++ ){
 573             dirList[ SourceDirName(orderedFileNames[i], TRUE) ]= 0;
 574         }
 575
 576         POSITION next;
 577         CString name;
 578         void *pVal;
 579
 580         next = dirList.GetStartPosition();
 581         while( next ){
 582             dirList.GetNextAssoc( next, name, pVal);
 583             CString dirDefine = DirDefine( name );
 584             CString ext = GetExt( name );
 585             name = SourceDirName( name, FALSE );
 586             CString response = dirDefine.Left(8);
 587
 588             fprintf( pAltFile,
 589                 "\n\n\n{%s}%s{$(OUTDIR)}.obj:\n"
 590                 "\t@rem <<$(OUTDIR)\\%s.cl\n"
 591                 "\t$(CFILEFLAGS)\n"
 592                 "\t$(CFLAGS_%s)\n"
 593                 "<<KEEP\n"
 594                 "\t$(CPP) @$(OUTDIR)\\%s.cl %%s\n",
 595                 (const char*)name,
 596                 (const char*)ext,
 597                 (const char*)response,
 598                 (const char*)dirDefine,
 599                 (const char*)response
 600             );
 601
 602             fprintf( pAltFile,
 603                 "\n\n\nBATCH_%s:\n"
 604                 "\t@rem <<$(OUTDIR)\\%s.cl\n"
 605                 "\t$(CFILEFLAGS)\n"
 606                 "\t$(CFLAGS_%s)\n"
 607                 "\t$(FILES_%s)\n"
 608                 "<<KEEP\n"
 609                 "\t$(TIMESTART)\n"
 610                 "\t$(CPP) @$(OUTDIR)\\%s.cl\n"
 611                 "\t$(TIMESTOP)\n",
 612                 (const char*)dirDefine,
 613                 (const char*)response,
 614                 (const char*)dirDefine,
 615                 (const char*)dirDefine,
 616                 (const char*)response
 617             );
 618         }
 619
 620         //
 621         // Loop through one more time and build the final batch build
 622         //  rule
 623         //
 624         fprintf( pAltFile,
 625             "\n\n\nBATCH_BUILD_OBJECTS:\t\t\\\n");
 626
 627         next = dirList.GetStartPosition();
 628         while( next ){
 629             dirList.GetNextAssoc( next, name, pVal);
 630             CString dirDefine = DirDefine( name );
 631
 632             fprintf( pAltFile,
 633                 "\tBATCH_%s\t\t\\\n", dirDefine );
 634         }
 635
 636         fprintf( pAltFile,
 637             "\n\n");
 638     }
 639
 640
 641     static void ProcessFiles(){
 642         CFileRecord *pRec;
 643         BOOL bFound;
 644         POSITION next;
 645         CString name;
 646
 647                 // search all the files for headers, adding each one to the list when found
 648                 // rather than do it recursively, it simple marks each one it's done
 649                 // and starts over, stopping only when all are marked as done
 650
 651         next = fileMap.GetStartPosition();
 652         while( next ){
 653             fileMap.GetNextAssoc( next, name, *(void**)&pRec );
 654             if( pRec->m_bVisited == FALSE && pRec->m_bSystem == FALSE ){
 655                                 // mark this file as already done so we don't read it again
 656                                 // to find its headers
 657                 pRec->m_bVisited = TRUE;
 658                 pRec->ProcessFile();
 659                 // Start searching from the beginning again
 660                                 // because ProcessFile may have added new files
 661                                 // and changed the GetNextAssoc order
 662                 next = fileMap.GetStartPosition();
 663
 664             }
 665         }
 666     }
 667
 668
 669 };
 670
 671 CMapStringToPtr CFileRecord::fileMap;           // contains all allocated CFileRecords
 672 CStringArray CFileRecord::orderedFileNames;
 673 CMapStringToPtr CFileRecord::includeMap;        // pointers to CFileRecords in fileMap
 674 CMapStringToPtr CFileRecord::noDependMap;       // no data, just an index
 675
 676 int main( int argc, char** argv ){
 677     int i = 1;
 678     char *pStr;
 679     static int iRecursion = 0;  //      Track levels of recursion.
 680         static CString outputFileName;
 681
 682     //  Entering.
 683     iRecursion++;
 684
 685     while( i < argc ){
 686         if( argv[i][0] == '-' || argv[i][0] == '/' ){
 687             switch( argv[i][1] ){
 688
 689             case 'i':
 690             case 'I':
 691                 if( argv[i][2] != 0 ){
 692                     pStr = &(argv[i][2]);
 693                 }
 694                 else {
 695                     i++;
 696                     pStr = argv[i];
 697                 }
 698                 if( pStr == 0 || *pStr == '-' || *pStr == '/' ){
 699                     goto usage;
 700                 }
 701                 else {
 702                     AddIncludeDirectory( pStr );
 703                 }
 704                 break;
 705
 706             case 'f':
 707             case 'F':
 708                 if( argv[i][2] != 0 ){
 709                     pStr = &(argv[i][2]);
 710                 }
 711                 else {
 712                     i++;
 713                     pStr = argv[i];
 714                 }
 715                 if( pStr == 0 || *pStr == '-' || *pStr == '/'){
 716                     goto usage;
 717                 }
 718                 else {
 719                     CStdioFile f;
 720                     CString s;
 721                     if( f.Open( pStr, CFile::modeRead ) ){
 722                         while(f.ReadString(s)){
 723                             s.TrimLeft();
 724                             s.TrimRight();
 725                             if( s.GetLength() ){
 726                                 CFileRecord::AddFile( s, NULL, FALSE, TRUE );
 727                             }
 728                         }
 729                         f.Close();
 730                     }
 731                     else {
 732                         fprintf(stderr,"makedep: file not found: %s", pStr );
 733                         exit(-1);
 734                     }
 735                 }
 736                 break;
 737
 738             case 'o':
 739             case 'O':
 740                 if( argv[i][2] != 0 ){
 741                     pStr = &(argv[i][2]);
 742                 }
 743                 else {
 744                     i++;
 745                     pStr = argv[i];
 746                 }
 747                 if( pStr == 0 || *pStr == '-' || *pStr == '/'){
 748                     goto usage;
 749                 }
 750                 else {
 751                     CStdioFile f;
 752                     CString s;
 753                                         outputFileName = pStr;
 754                                         if(!(pAltFile = fopen(pStr, "w+")))     {
 755                         fprintf(stderr, "makedep: file not found: %s", pStr );
 756                         exit(-1);
 757                     }
 758                 }
 759                 break;
 760
 761             case '1':
 762                 if( argv[i][2] == '6')  {
 763                     b16 = TRUE;
 764                 }
 765                 break;
 766
 767             case 's':
 768             case 'S':
 769                 bSimple = TRUE;
 770                 break;
 771
 772
 773
 774             case 'h':
 775             case 'H':
 776             case '?':
 777             usage:
 778                 fprintf(stderr, "usage: makedep -I <dirname> -F <filelist> <filename>\n"
 779                        "  -I <dirname>    Directory name, can be repeated\n"
 780                        "  -F <filelist>   List of files to scan, one per line\n"
 781                        "  -O <outputFile> File to write output, default stdout\n");
 782                 exit(-1);
 783             }
 784         }
 785         else if( argv[i][0] == '@' ){
 786                 //      file contains our commands.
 787                 CStdioFile f;
 788             CString s;
 789             int iNewArgc = 0;
 790             char **apNewArgv = new char*[5000];
 791                         memset(apNewArgv, 0, sizeof(apNewArgv));
 792
 793                         //      First one is always the name of the exe.
 794                         apNewArgv[0] = argv[0];
 795                         iNewArgc++;
 796
 797                         const char *pTraverse;
 798                         const char *pBeginArg;
 799                 if( f.Open( &argv[i][1], CFile::modeRead ) ){
 800                 while( iNewArgc < 5000 && f.ReadString(s) )     {
 801                                         //      Scan the string for args, and do the right thing.
 802                                         pTraverse = (const char *)s;
 803                                         while(iNewArgc < 5000 && *pTraverse)    {
 804                                                 if(isspace(*pTraverse)) {
 805                                                                 pTraverse++;
 806                                                                 continue;
 807                                                 }
 808
 809                                                 //      Extract to next space.
 810                                                 pBeginArg = pTraverse;
 811                                                 do      {
 812                                                         pTraverse++;
 813                                                 }
 814                                                 while(*pTraverse && !isspace(*pTraverse));
 815                                                 apNewArgv[iNewArgc] = new char[pTraverse - pBeginArg + 1];
 816                                                 memset(apNewArgv[iNewArgc], 0, pTraverse - pBeginArg + 1);
 817                                                 strncpy(apNewArgv[iNewArgc], pBeginArg, pTraverse - pBeginArg);
 818                                                 iNewArgc++;
 819                                         }
 820                     }
 821                 f.Close();
 822                 }
 823
 824                 //      Recurse if needed.
 825                 if(iNewArgc > 1)        {
 826                         main(iNewArgc, apNewArgv);
 827                 }
 828
 829                 //      Free off the argvs (but not the very first one which we didn't allocate).
 830                 while(iNewArgc > 1)     {
 831                         iNewArgc--;
 832                         delete [] apNewArgv[iNewArgc];
 833                 }
 834                 delete [] apNewArgv;
 835         }
 836         else {
 837             CFileRecord::AddFile( argv[i], NULL, FALSE, TRUE );
 838         }
 839         i++;
 840     }
 841
 842     //  Only of the very bottom level of recursion do we do this.
 843     if(iRecursion == 1) {
 844
 845                 // only write the results out if no errors encountered
 846                 if (mainReturn == 0) {
 847                         CFileRecord::ProcessFiles();
 848             if( !bSimple ){
 849                         CFileRecord::PrintTargets("OBJ_FILES", "\\");
 850                 if(b16) {
 851                             CFileRecord::PrintTargets("LINK_OBJS", "+\\");
 852                 }
 853                 else    {
 854                             CFileRecord::PrintTargets("LINK_OBJS", "^");
 855                 }
 856                 CFileRecord::PrintSources();
 857                 CFileRecord::PrintBuildRules();
 858             }
 859                 CFileRecord::PrintDependancies();
 860                 }
 861
 862                 if(pAltFile != stdout)  {
 863                         fclose(pAltFile);
 864                         if (mainReturn != 0) {
 865                                 remove(outputFileName); // kill output file if returning an error
 866                         }
 867                 }
 868         }
 869         iRecursion--;
 870
 871     if (iRecursion == 0 )
 872     {
 873         // last time through -- clean up allocated CFileRecords!
 874         CFileRecord *pFRec;
 875         CString     name;
 876         POSITION    next;
 877
 878         next = CFileRecord::fileMap.GetStartPosition();
 879         while( next ){
 880             CFileRecord::fileMap.GetNextAssoc( next, name, *(void**)&pFRec );
 881             delete pFRec;
 882         }
 883     }
 884
 885     return mainReturn;
 886 }