main.c

   1 /*
   2 *   $Id: main.c 536 2007-06-02 06:09:00Z elliotth $
   3 *
   4 *   Copyright (c) 1996-2003, Darren Hiebert
   5 *
   6 *   Author: Darren Hiebert <dhiebert@users.sourceforge.net>
   7 *           http://ctags.sourceforge.net
   8 *
   9 *   This source code is released for free distribution under the terms of the
  10 *   GNU General Public License. It is provided on an as-is basis and no
  11 *   responsibility is accepted for its failure to perform as expected.
  12 *
  13 *   This is a reimplementation of the ctags (1) program. It is an attempt to
  14 *   provide a fully featured ctags program which is free of the limitations
  15 *   which most (all?) others are subject to.
  16 *
  17 *   This module contains the start-up code and routines to determine the list
  18 *   of files to parsed for tags.
  19 */
  20
  21 /*
  22 *   INCLUDE FILES
  23 */
  24 #include "general.h"  /* must always come first */
  25
  26 #include <string.h>
  27
  28 /*  To provide timings features if available.
  29  */
  30 #ifdef HAVE_CLOCK
  31 # ifdef HAVE_TIME_H
  32 #  include <time.h>
  33 # endif
  34 #else
  35 # ifdef HAVE_TIMES
  36 #  ifdef HAVE_SYS_TIMES_H
  37 #   include <sys/times.h>
  38 #  endif
  39 # endif
  40 #endif
  41
  42 /*  To provide directory searching for recursion feature.
  43  */
  44 #ifdef AMIGA
  45 # include <dos/dosasl.h>       /* for struct AnchorPath */
  46 # include <clib/dos_protos.h>  /* function prototypes */
  47 # define ANCHOR_BUF_SIZE 512
  48 # define ANCHOR_SIZE (sizeof (struct AnchorPath) + ANCHOR_BUF_SIZE)
  49 # ifdef __SASC
  50    extern struct DosLibrary *DOSBase;
  51 #  include <pragmas/dos_pragmas.h>
  52 # endif
  53 #endif
  54
  55 #ifdef HAVE_DIRENT_H
  56 # ifdef __BORLANDC__
  57 #  define boolean BORLAND_boolean
  58 # endif
  59 # ifdef HAVE_SYS_TYPES_H
  60 #  include <sys/types.h>  /* required by dirent.h */
  61 # endif
  62 # include <dirent.h>  /* to declare opendir() */
  63 # undef boolean
  64 #endif
  65 #ifdef HAVE_DIRECT_H
  66 # include <direct.h>  /* to _getcwd() */
  67 #endif
  68 #ifdef HAVE_DOS_H
  69 # include <dos.h>  /* to declare FA_DIREC */
  70 #endif
  71 #ifdef HAVE_DIR_H
  72 # include <dir.h>  /* to declare findfirst() and findnext */
  73 #endif
  74 #ifdef HAVE_IO_H
  75 # include <io.h>  /* to declare _findfirst() */
  76 #endif
  77
  78
  79 #include "debug.h"
  80 #include "keyword.h"
  81 #include "main.h"
  82 #include "options.h"
  83 #include "read.h"
  84 #include "routines.h"
  85
  86 /*
  87 *   MACROS
  88 */
  89 #define plural(value)  (((unsigned long)(value) == 1L) ? "" : "s")
  90
  91 /*
  92 *   DATA DEFINITIONS
  93 */
  94 static struct { long files, lines, bytes; } Totals = { 0, 0, 0 };
  95
  96 #ifdef AMIGA
  97 # include "ctags.h"
  98   static const char *VERsion = "$VER: "PROGRAM_NAME" "PROGRAM_VERSION" "
  99 # ifdef __SASC
 100   __AMIGADATE__
 101 # else
 102   __DATE__
 103 # endif
 104   " "AUTHOR_NAME" $";
 105 #endif
 106
 107 /*
 108 *   FUNCTION PROTOTYPES
 109 */
 110 static boolean createTagsForEntry (const char *const entryName);
 111
 112 /*
 113 *   FUNCTION DEFINITIONS
 114 */
 115
 116 extern void addTotals (
 117                 const unsigned int files, const long unsigned int lines,
 118                 const long unsigned int bytes)
 119 {
 120         Totals.files += files;
 121         Totals.lines += lines;
 122         Totals.bytes += bytes;
 123 }
 124
 125 extern boolean isDestinationStdout (void)
 126 {
 127         boolean toStdout = FALSE;
 128
 129         if (Option.xref  ||  Option.filter  ||
 130                 (Option.tagFileName != NULL  &&  (strcmp (Option.tagFileName, "-") == 0
 131 #if defined (VMS)
 132         || strcmp (Option.tagFileName, "sys$output") == 0
 133 #else
 134         || strcmp (Option.tagFileName, "/dev/stdout") == 0
 135 #endif
 136                 )))
 137                 toStdout = TRUE;
 138         return toStdout;
 139 }
 140
 141 #if defined (HAVE_OPENDIR)
 142 static boolean recurseUsingOpendir (const char *const dirName)
 143 {
 144         boolean resize = FALSE;
 145         DIR *const dir = opendir (dirName);
 146         if (dir == NULL)
 147                 error (WARNING | PERROR, "cannot recurse into directory \"%s\"", dirName);
 148         else
 149         {
 150                 struct dirent *entry;
 151                 while ((entry = readdir (dir)) != NULL)
 152                 {
 153                         if (strcmp (entry->d_name, ".") != 0  &&
 154                                 strcmp (entry->d_name, "..") != 0)
 155                         {
 156                                 vString *filePath;
 157                                 if (strcmp (dirName, ".") == 0)
 158                                         filePath = vStringNewInit (entry->d_name);
 159                                 else
 160                                         filePath = combinePathAndFile (dirName, entry->d_name);
 161                                 resize |= createTagsForEntry (vStringValue (filePath));
 162                                 vStringDelete (filePath);
 163                         }
 164                 }
 165                 closedir (dir);
 166         }
 167         return resize;
 168 }
 169
 170 #elif defined (HAVE_FINDFIRST) || defined (HAVE__FINDFIRST)
 171
 172 static boolean createTagsForWildcardEntry (
 173                 const char *const pattern, const size_t dirLength,
 174                 const char *const entryName)
 175 {
 176         boolean resize = FALSE;
 177         /* we must not recurse into the directories "." or ".." */
 178         if (strcmp (entryName, ".") != 0  &&  strcmp (entryName, "..") != 0)
 179         {
 180                 vString *const filePath = vStringNew ();
 181                 vStringNCopyS (filePath, pattern, dirLength);
 182                 vStringCatS (filePath, entryName);
 183                 resize = createTagsForEntry (vStringValue (filePath));
 184                 vStringDelete (filePath);
 185         }
 186         return resize;
 187 }
 188
 189 static boolean createTagsForWildcardUsingFindfirst (const char *const pattern)
 190 {
 191         boolean resize = FALSE;
 192         const size_t dirLength = baseFilename (pattern) - pattern;
 193 #if defined (HAVE_FINDFIRST)
 194         struct ffblk fileInfo;
 195         int result = findfirst (pattern, &fileInfo, FA_DIREC);
 196         while (result == 0)
 197         {
 198                 const char *const entry = (const char *) fileInfo.ff_name;
 199                 resize |= createTagsForWildcardEntry (pattern, dirLength, entry);
 200                 result = findnext (&fileInfo);
 201         }
 202 #elif defined (HAVE__FINDFIRST)
 203         struct _finddata_t fileInfo;
 204         findfirst_t hFile = _findfirst (pattern, &fileInfo);
 205         if (hFile != -1L)
 206         {
 207                 do
 208                 {
 209                         const char *const entry = (const char *) fileInfo.name;
 210                         resize |= createTagsForWildcardEntry (pattern, dirLength, entry);
 211                 } while (_findnext (hFile, &fileInfo) == 0);
 212                 _findclose (hFile);
 213         }
 214 #endif
 215         return resize;
 216 }
 217
 218 #elif defined (AMIGA)
 219
 220 static boolean createTagsForAmigaWildcard (const char *const pattern)
 221 {
 222         boolean resize = FALSE;
 223         struct AnchorPath *const anchor =
 224                         (struct AnchorPath *) eMalloc ((size_t) ANCHOR_SIZE);
 225         LONG result;
 226
 227         memset (anchor, 0, (size_t) ANCHOR_SIZE);
 228         anchor->ap_Strlen = ANCHOR_BUF_SIZE;
 229         /* Allow '.' for current directory */
 230 #ifdef APF_DODOT
 231         anchor->ap_Flags = APF_DODOT | APF_DOWILD;
 232 #else
 233         anchor->ap_Flags = APF_DoDot | APF_DoWild;
 234 #endif
 235         result = MatchFirst ((UBYTE *) pattern, anchor);
 236         while (result == 0)
 237         {
 238                 resize |= createTagsForEntry ((char *) anchor->ap_Buf);
 239                 result = MatchNext (anchor);
 240         }
 241         MatchEnd (anchor);
 242         eFree (anchor);
 243         return resize;
 244 }
 245 #endif
 246
 247 static boolean recurseIntoDirectory (const char *const dirName)
 248 {
 249         boolean resize = FALSE;
 250         if (isRecursiveLink (dirName))
 251                 verbose ("ignoring \"%s\" (recursive link)\n", dirName);
 252         else if (! Option.recurse)
 253                 verbose ("ignoring \"%s\" (directory)\n", dirName);
 254         else
 255         {
 256                 verbose ("RECURSING into directory \"%s\"\n", dirName);
 257 #if defined (HAVE_OPENDIR)
 258                 resize = recurseUsingOpendir (dirName);
 259 #elif defined (HAVE_FINDFIRST) || defined (HAVE__FINDFIRST)
 260                 {
 261                         vString *const pattern = vStringNew ();
 262                         vStringCopyS (pattern, dirName);
 263                         vStringPut (pattern, OUTPUT_PATH_SEPARATOR);
 264                         vStringCatS (pattern, "*.*");
 265                         resize = createTagsForWildcardUsingFindfirst (vStringValue (pattern));
 266                         vStringDelete (pattern);
 267                 }
 268 #elif defined (AMIGA)
 269                 {
 270                         vString *const pattern = vStringNew ();
 271                         if (*dirName != '\0'  &&  strcmp (dirName, ".") != 0)
 272                         {
 273                                 vStringCopyS (pattern, dirName);
 274                                 if (dirName [strlen (dirName) - 1] != '/')
 275                                         vStringPut (pattern, '/');
 276                         }
 277                         vStringCatS (pattern, "#?");
 278                         resize = createTagsForAmigaWildcard (vStringValue (pattern));
 279                         vStringDelete (pattern);
 280                 }
 281 #endif
 282         }
 283         return resize;
 284 }
 285
 286 static boolean createTagsForEntry (const char *const entryName)
 287 {
 288         boolean resize = FALSE;
 289         fileStatus *status = eStat (entryName);
 290
 291         Assert (entryName != NULL);
 292         if (isExcludedFile (entryName))
 293                 verbose ("excluding \"%s\"\n", entryName);
 294         else if (status->isSymbolicLink  &&  ! Option.followLinks)
 295                 verbose ("ignoring \"%s\" (symbolic link)\n", entryName);
 296         else if (! status->exists)
 297                 error (WARNING | PERROR, "cannot open source file \"%s\"", entryName);
 298         else if (status->isDirectory)
 299                 resize = recurseIntoDirectory (entryName);
 300         else if (! status->isNormalFile)
 301                 verbose ("ignoring \"%s\" (special file)\n", entryName);
 302         else
 303                 resize = parseFile (entryName);
 304
 305         eStatFree (status);
 306         return resize;
 307 }
 308
 309 #ifdef MANUAL_GLOBBING
 310
 311 static boolean createTagsForWildcardArg (const char *const arg)
 312 {
 313         boolean resize = FALSE;
 314         vString *const pattern = vStringNewInit (arg);
 315         char *patternS = vStringValue (pattern);
 316
 317 #if defined (HAVE_FINDFIRST) || defined (HAVE__FINDFIRST)
 318         /*  We must transform the "." and ".." forms into something that can
 319          *  be expanded by the findfirst/_findfirst functions.
 320          */
 321         if (Option.recurse  &&
 322                 (strcmp (patternS, ".") == 0  ||  strcmp (patternS, "..") == 0))
 323         {
 324                 vStringPut (pattern, OUTPUT_PATH_SEPARATOR);
 325                 vStringCatS (pattern, "*.*");
 326         }
 327         resize |= createTagsForWildcardUsingFindfirst (patternS);
 328 #endif
 329         vStringDelete (pattern);
 330         return resize;
 331 }
 332
 333 #endif
 334
 335 static boolean createTagsForArgs (cookedArgs *const args)
 336 {
 337         boolean resize = FALSE;
 338
 339         /*  Generate tags for each argument on the command line.
 340          */
 341         while (! cArgOff (args))
 342         {
 343                 const char *const arg = cArgItem (args);
 344
 345 #ifdef MANUAL_GLOBBING
 346                 resize |= createTagsForWildcardArg (arg);
 347 #else
 348                 resize |= createTagsForEntry (arg);
 349 #endif
 350                 cArgForth (args);
 351                 parseOptions (args);
 352         }
 353         return resize;
 354 }
 355
 356 /*  Read from an opened file a list of file names for which to generate tags.
 357  */
 358 static boolean createTagsFromFileInput (FILE *const fp, const boolean filter)
 359 {
 360         boolean resize = FALSE;
 361         if (fp != NULL)
 362         {
 363                 cookedArgs *args = cArgNewFromLineFile (fp);
 364                 parseOptions (args);
 365                 while (! cArgOff (args))
 366                 {
 367                         resize |= createTagsForEntry (cArgItem (args));
 368                         if (filter)
 369                         {
 370                                 if (Option.filterTerminator != NULL)
 371                                         fputs (Option.filterTerminator, stdout);
 372                                 fflush (stdout);
 373                         }
 374                         cArgForth (args);
 375                         parseOptions (args);
 376                 }
 377                 cArgDelete (args);
 378         }
 379         return resize;
 380 }
 381
 382 /*  Read from a named file a list of file names for which to generate tags.
 383  */
 384 static boolean createTagsFromListFile (const char *const fileName)
 385 {
 386         boolean resize;
 387         Assert (fileName != NULL);
 388         if (strcmp (fileName, "-") == 0)
 389                 resize = createTagsFromFileInput (stdin, FALSE);
 390         else
 391         {
 392                 FILE *const fp = fopen (fileName, "r");
 393                 if (fp == NULL)
 394                         error (FATAL | PERROR, "cannot open list file \"%s\"", fileName);
 395                 resize = createTagsFromFileInput (fp, FALSE);
 396                 fclose (fp);
 397         }
 398         return resize;
 399 }
 400
 401 #if defined (HAVE_CLOCK)
 402 # define CLOCK_AVAILABLE
 403 # ifndef CLOCKS_PER_SEC
 404 #  define CLOCKS_PER_SEC                1000000
 405 # endif
 406 #elif defined (HAVE_TIMES)
 407 # define CLOCK_AVAILABLE
 408 # define CLOCKS_PER_SEC 60
 409 static clock_t clock (void)
 410 {
 411         struct tms buf;
 412
 413         times (&buf);
 414         return (buf.tms_utime + buf.tms_stime);
 415 }
 416 #else
 417 # define clock()  (clock_t)0
 418 #endif
 419
 420 static void printTotals (const clock_t *const timeStamps)
 421 {
 422         const unsigned long totalTags = TagFile.numTags.added +
 423                                                                         TagFile.numTags.prev;
 424
 425         fprintf (errout, "%ld file%s, %ld line%s (%ld kB) scanned",
 426                         Totals.files, plural (Totals.files),
 427                         Totals.lines, plural (Totals.lines),
 428                         Totals.bytes/1024L);
 429 #ifdef CLOCK_AVAILABLE
 430         {
 431                 const double interval = ((double) (timeStamps [1] - timeStamps [0])) /
 432                                                                 CLOCKS_PER_SEC;
 433
 434                 fprintf (errout, " in %.01f seconds", interval);
 435                 if (interval != (double) 0.0)
 436                         fprintf (errout, " (%lu kB/s)",
 437                                         (unsigned long) (Totals.bytes / interval) / 1024L);
 438         }
 439 #endif
 440         fputc ('\n', errout);
 441
 442         fprintf (errout, "%lu tag%s added to tag file",
 443                         TagFile.numTags.added, plural (TagFile.numTags.added));
 444         if (Option.append)
 445                 fprintf (errout, " (now %lu tags)", totalTags);
 446         fputc ('\n', errout);
 447
 448         if (totalTags > 0  &&  Option.sorted != SO_UNSORTED)
 449         {
 450                 fprintf (errout, "%lu tag%s sorted", totalTags, plural (totalTags));
 451 #ifdef CLOCK_AVAILABLE
 452                 fprintf (errout, " in %.02f seconds",
 453                                 ((double) (timeStamps [2] - timeStamps [1])) / CLOCKS_PER_SEC);
 454 #endif
 455                 fputc ('\n', errout);
 456         }
 457
 458 #ifdef DEBUG
 459         fprintf (errout, "longest tag line = %lu\n",
 460                         (unsigned long) TagFile.max.line);
 461 #endif
 462 }
 463
 464 static boolean etagsInclude (void)
 465 {
 466         return (boolean)(Option.etags && Option.etagsInclude != NULL);
 467 }
 468
 469 static void makeTags (cookedArgs *args)
 470 {
 471         clock_t timeStamps [3];
 472         boolean resize = FALSE;
 473         boolean files = (boolean)(! cArgOff (args) || Option.fileList != NULL
 474                                                           || Option.filter);
 475
 476         if (! files)
 477         {
 478                 if (filesRequired ())
 479                         error (FATAL, "No files specified. Try \"%s --help\".",
 480                                 getExecutableName ());
 481                 else if (! Option.recurse && ! etagsInclude ())
 482                         return;
 483         }
 484
 485 #define timeStamp(n) timeStamps[(n)]=(Option.printTotals ? clock():(clock_t)0)
 486         if (! Option.filter)
 487                 openTagFile ();
 488
 489         timeStamp (0);
 490
 491         if (! cArgOff (args))
 492         {
 493                 verbose ("Reading command line arguments\n");
 494                 resize = createTagsForArgs (args);
 495         }
 496         if (Option.fileList != NULL)
 497         {
 498                 verbose ("Reading list file\n");
 499                 resize = (boolean) (createTagsFromListFile (Option.fileList) || resize);
 500         }
 501         if (Option.filter)
 502         {
 503                 verbose ("Reading filter input\n");
 504                 resize = (boolean) (createTagsFromFileInput (stdin, TRUE) || resize);
 505         }
 506         if (! files  &&  Option.recurse)
 507                 resize = recurseIntoDirectory (".");
 508
 509         timeStamp (1);
 510
 511         if (! Option.filter)
 512                 closeTagFile (resize);
 513
 514         timeStamp (2);
 515
 516         if (Option.printTotals)
 517                 printTotals (timeStamps);
 518 #undef timeStamp
 519 }
 520
 521 /*
 522  *              Start up code
 523  */
 524
 525 extern int main (int __unused__ argc, char **argv)
 526 {
 527         cookedArgs *args;
 528 #ifdef VMS
 529         extern int getredirection (int *ac, char ***av);
 530
 531         /* do wildcard expansion and I/O redirection */
 532         getredirection (&argc, &argv);
 533 #endif
 534
 535 #ifdef AMIGA
 536         /* This program doesn't work when started from the Workbench */
 537         if (argc == 0)
 538                 exit (1);
 539 #endif
 540
 541 #ifdef __EMX__
 542         _wildcard (&argc, &argv);  /* expand wildcards in argument list */
 543 #endif
 544
 545 #if defined (macintosh) && BUILD_MPW_TOOL == 0
 546         argc = ccommand (&argv);
 547 #endif
 548
 549         setCurrentDirectory ();
 550         setExecutableName (*argv++);
 551         checkRegex ();
 552
 553         args = cArgNewFromArgv (argv);
 554         previewFirstOption (args);
 555         testEtagsInvocation ();
 556         initializeParsing ();
 557         initOptions ();
 558         readOptionConfiguration ();
 559         verbose ("Reading initial options from command line\n");
 560         parseOptions (args);
 561         checkOptions ();
 562         makeTags (args);
 563
 564         /*  Clean up.
 565          */
 566         cArgDelete (args);
 567         freeKeywordTable ();
 568         freeRoutineResources ();
 569         freeSourceFileResources ();
 570         freeTagFileResources ();
 571         freeOptionResources ();
 572         freeParserResources ();
 573         freeRegexResources ();
 574
 575         exit (0);
 576         return 0;
 577 }
 578
 579 /* vi:set tabstop=4 shiftwidth=4: */