tagmanager/read.c

   1 /*
   2 *   $Id$
   3 *
   4 *   Copyright (c) 1996-2002, Darren Hiebert
   5 *
   6 *   This source code is released for free distribution under the terms of the
   7 *   GNU General Public License.
   8 *
   9 *   This module contains low level source and tag file read functions (newline
  10 *   conversion for source files are performed at this level).
  11 */
  12
  13 /*
  14 *   INCLUDE FILES
  15 */
  16 #include "general.h"  /* must always come first */
  17
  18 #include <string.h>
  19 #include <ctype.h>
  20
  21 #define FILE_WRITE
  22 #include "read.h"
  23 #include "debug.h"
  24 #include "entry.h"
  25 #include "main.h"
  26 #include "routines.h"
  27 #include "options.h"
  28
  29 /*
  30 *   DATA DEFINITIONS
  31 */
  32 inputFile File;  /* globally read through macros */
  33 static fpos_t StartOfLine;  /* holds deferred position of start of line */
  34 static int bufferStartOfLine;    /* the same as StartOfLine but for buffer */
  35
  36 /*
  37 *   FUNCTION DEFINITIONS
  38 */
  39
  40 /*
  41 *   FORWARD
  42 */
  43
  44 static int readNextChar (void);
  45 static int pushBackChar (int c);
  46
  47
  48 extern void freeSourceFileResources (void)
  49 {
  50         vStringDelete (File.name);
  51         vStringDelete (File.path);
  52         vStringDelete (File.source.name);
  53         vStringDelete (File.line);
  54 }
  55
  56 /*
  57  *   Source file access functions
  58  */
  59
  60 static void setInputFileName (const char *const fileName)
  61 {
  62         const char *const head = fileName;
  63         const char *const tail = baseFilename (head);
  64
  65         if (File.name != NULL)
  66                 vStringDelete (File.name);
  67         File.name = vStringNewInit (fileName);
  68
  69         if (File.path != NULL)
  70                 vStringDelete (File.path);
  71         if (tail == head)
  72                 File.path = NULL;
  73         else
  74         {
  75                 const size_t length = tail - head - 1;
  76                 File.path = vStringNew ();
  77                 vStringNCopyS (File.path, fileName, length);
  78         }
  79 }
  80
  81 static void setSourceFileParameters (vString *const fileName)
  82 {
  83         if (File.source.name != NULL)
  84                 vStringDelete (File.source.name);
  85         File.source.name = fileName;
  86
  87         if (File.source.tagPath != NULL)
  88                 eFree (File.source.tagPath);
  89         if (! Option.tagRelative || isAbsolutePath (vStringValue (fileName)))
  90                 File.source.tagPath = eStrdup (vStringValue (fileName));
  91         else
  92                 File.source.tagPath =
  93                                 relativeFilename (vStringValue (fileName), TagFile.directory);
  94
  95         if (vStringLength (fileName) > TagFile.max.file)
  96                 TagFile.max.file = vStringLength (fileName);
  97
  98         File.source.isHeader = isIncludeFile (vStringValue (fileName));
  99         File.source.language = getFileLanguage (vStringValue (fileName));
 100 }
 101
 102 static boolean setSourceFileName (vString *const fileName)
 103 {
 104         boolean result = FALSE;
 105         if (getFileLanguage (vStringValue (fileName)) != LANG_IGNORE)
 106         {
 107                 vString *pathName;
 108                 if (isAbsolutePath (vStringValue (fileName)) || File.path == NULL)
 109                         pathName = vStringNewCopy (fileName);
 110                 else
 111                         pathName = combinePathAndFile (
 112                                         vStringValue (File.path), vStringValue (fileName));
 113                 setSourceFileParameters (pathName);
 114                 result = TRUE;
 115         }
 116         return result;
 117 }
 118
 119 /*
 120  *   Line directive parsing
 121  */
 122
 123 static int skipWhite (void)
 124 {
 125         int c;
 126         do
 127                 c = readNextChar ();
 128         while (c == ' '  ||  c == '\t');
 129         return c;
 130 }
 131
 132 static unsigned long readLineNumber (void)
 133 {
 134         unsigned long lNum = 0;
 135         int c = skipWhite ();
 136         while (c != EOF  &&  isdigit (c))
 137         {
 138                 lNum = (lNum * 10) + (c - '0');
 139                 c = readNextChar ();
 140         }
 141         pushBackChar (c);
 142         if (c != ' '  &&  c != '\t')
 143                 lNum = 0;
 144
 145         return lNum;
 146 }
 147
 148 /* While ANSI only permits lines of the form:
 149  *   # line n "filename"
 150  * Earlier compilers generated lines of the form
 151  *   # n filename
 152  * GNU C will output lines of the form:
 153  *   # n "filename"
 154  * So we need to be fairly flexible in what we accept.
 155  */
 156 static vString *readFileName (void)
 157 {
 158         vString *const fileName = vStringNew ();
 159         boolean quoteDelimited = FALSE;
 160         int c = skipWhite ();
 161
 162         if (c == '"')
 163         {
 164                 c = readNextChar ();  /* skip double-quote */
 165                 quoteDelimited = TRUE;
 166         }
 167         while (c != EOF  &&  c != '\n'  &&
 168                         (quoteDelimited ? (c != '"') : (c != ' '  &&  c != '\t')))
 169         {
 170                 vStringPut (fileName, c);
 171                 c = readNextChar ();
 172         }
 173         if (c == '\n')
 174                 pushBackChar (c);
 175         vStringPut (fileName, '\0');
 176
 177         return fileName;
 178 }
 179
 180 static boolean parseLineDirective (void)
 181 {
 182         boolean result = FALSE;
 183         int c = skipWhite ();
 184         DebugStatement ( const char* lineStr = ""; )
 185
 186         if (isdigit (c))
 187         {
 188                 pushBackChar (c);
 189                 result = TRUE;
 190         }
 191         else if (c == 'l'  &&  readNextChar () == 'i'  &&
 192                          readNextChar () == 'n'  &&  readNextChar () == 'e')
 193         {
 194                 c = readNextChar ();
 195                 if (c == ' '  ||  c == '\t')
 196                 {
 197                         DebugStatement ( lineStr = "line"; )
 198                         result = TRUE;
 199                 }
 200         }
 201         if (result)
 202         {
 203                 const unsigned long lNum = readLineNumber ();
 204                 if (lNum == 0)
 205                         result = FALSE;
 206                 else
 207                 {
 208                         vString *const fileName = readFileName ();
 209                         if (vStringLength (fileName) == 0)
 210                         {
 211                                 File.source.lineNumber = lNum - 1;  /* applies to NEXT line */
 212                                 DebugStatement ( debugPrintf (DEBUG_RAW, "#%s %ld", lineStr, lNum); )
 213                         }
 214                         else if (setSourceFileName (fileName))
 215                         {
 216                                 File.source.lineNumber = lNum - 1;  /* applies to NEXT line */
 217                                 DebugStatement ( debugPrintf (DEBUG_RAW, "#%s %ld \"%s\"",
 218                                                                 lineStr, lNum, vStringValue (fileName)); )
 219                         }
 220
 221                         if (Option.include.fileNames && vStringLength (fileName) > 0 &&
 222                                 lNum == 1)
 223                         {
 224                                 tagEntryInfo tag;
 225                                 initTagEntry (&tag, baseFilename (vStringValue (fileName)));
 226
 227                                 tag.isFileEntry     = TRUE;
 228                                 tag.lineNumberEntry = TRUE;
 229                                 tag.lineNumber      = 1;
 230                                 tag.kindName        = "file";
 231                                 tag.kind            = 'F';
 232
 233                                 makeTagEntry (&tag);
 234                         }
 235                         vStringDelete (fileName);
 236                         result = TRUE;
 237                 }
 238         }
 239         return result;
 240 }
 241
 242 /*
 243  *   Source file I/O operations
 244  */
 245
 246 /*  This function opens a source file, and resets the line counter.  If it
 247  *  fails, it will display an error message and leave the File.fp set to NULL.
 248  */
 249 extern boolean fileOpen (const char *const fileName, const langType language)
 250 {
 251 #ifdef VMS
 252         const char *const openMode = "r";
 253 #else
 254         const char *const openMode = "rb";
 255 #endif
 256         boolean opened = FALSE;
 257
 258         /*      If another file was already open, then close it.
 259          */
 260         if (File.fp != NULL)
 261         {
 262                 fclose (File.fp);  /* close any open source file */
 263                 File.fp = NULL;
 264         }
 265
 266         File.fp = fopen (fileName, openMode);
 267         if (File.fp == NULL)
 268                 error (WARNING | PERROR, "cannot open \"%s\"", fileName);
 269         else
 270         {
 271                 opened = TRUE;
 272
 273                 setInputFileName (fileName);
 274                 fgetpos (File.fp, &StartOfLine);
 275                 fgetpos (File.fp, &File.filePosition);
 276                 File.currentLine  = NULL;
 277                 File.language     = language;
 278                 File.lineNumber   = 0L;
 279                 File.eof          = FALSE;
 280                 File.newLine      = TRUE;
 281
 282                 if (File.line != NULL)
 283                         vStringClear (File.line);
 284
 285                 setSourceFileParameters (vStringNewInit (fileName));
 286                 File.source.lineNumber = 0L;
 287
 288                 verbose ("OPENING %s as %s language %sfile\n", fileName,
 289                                 getLanguageName (language),
 290                                 File.source.isHeader ? "include " : "");
 291         }
 292         return opened;
 293 }
 294
 295 /* The user should take care of allocate and free the buffer param.
 296  * This func is NOT THREAD SAFE.
 297  * The user should not tamper with the buffer while this func is executing.
 298  */
 299 extern boolean bufferOpen (unsigned char *buffer, int buffer_size,
 300                                                                 const char *const fileName, const langType language )
 301 {
 302         boolean opened = FALSE;
 303
 304     /*  Check whether a file of a buffer were already open, then close them.
 305      */
 306     if (File.fp != NULL) {
 307                 fclose (File.fp);               /* close any open source file */
 308                 File.fp = NULL;
 309     }
 310
 311         if (File.fpBuffer != NULL) {
 312                 error(PERROR, "An unallocated buffer was found. Please check you called \
 313                 correctly bufferClose ()\n");
 314                 File.fpBuffer = NULL;
 315         }
 316
 317         /* check if we got a good buffer */
 318         if (buffer == NULL || buffer_size == 0) {
 319                 opened = FALSE;
 320                 return opened;
 321         }
 322
 323         opened = TRUE;
 324
 325         File.fpBuffer = buffer;
 326         setInputFileName (fileName);
 327         bufferStartOfLine = 0;
 328         File.fpBufferPosition = 0;
 329         File.fpBufferSize = buffer_size;
 330         File.currentLine  = NULL;
 331         File.language     = language;
 332         File.lineNumber   = 0L;
 333         File.eof          = FALSE;
 334         File.newLine      = TRUE;
 335
 336         if (File.line != NULL)
 337         vStringClear (File.line);
 338
 339         setSourceFileParameters (vStringNewInit (fileName));
 340         File.source.lineNumber = 0L;
 341
 342         verbose ("OPENING %s as %s language %sfile\n", fileName,
 343                 getLanguageName (language),
 344                 File.source.isHeader ? "include " : "");
 345
 346         return opened;
 347 }
 348
 349
 350 extern void fileClose (void)
 351 {
 352         if (File.fp != NULL)
 353         {
 354                 /*  The line count of the file is 1 too big, since it is one-based
 355                  *  and is incremented upon each newline.
 356                  */
 357                 if (Option.printTotals)
 358                 {
 359                         fileStatus *status = eStat (vStringValue (File.name));
 360                         addTotals (0, File.lineNumber - 1L, status->size);
 361                 }
 362                 fclose (File.fp);
 363                 File.fp = NULL;
 364         }
 365 }
 366
 367 /* user should take care of freeing the buffer */
 368 extern void bufferClose (void)
 369 {
 370     if (File.fpBuffer != NULL) {
 371                 File.fpBuffer = NULL;
 372     }
 373 }
 374
 375
 376 extern boolean fileEOF (void)
 377 {
 378         return File.eof;
 379 }
 380
 381 /*  Action to take for each encountered source newline.
 382  */
 383 static void fileNewline (void)
 384 {
 385         File.filePosition = StartOfLine;
 386         File.newLine = FALSE;
 387         File.lineNumber++;
 388         File.source.lineNumber++;
 389         DebugStatement ( if (Option.breakLine == File.lineNumber) lineBreak (); )
 390         DebugStatement ( debugPrintf (DEBUG_RAW, "%6ld: ", File.lineNumber); )
 391 }
 392
 393 /*  This function reads a single character from the stream, performing newline
 394  *  canonicalization.
 395  */
 396 static int iFileGetc (void)
 397 {
 398         int     c;
 399 readnext:
 400         c = readNextChar ();
 401
 402         /*      If previous character was a newline, then we're starting a line.
 403          */
 404         if (File.newLine  &&  c != EOF)
 405         {
 406                 fileNewline ();
 407                 if (c == '#'  &&  Option.lineDirectives)
 408                 {
 409                         if (parseLineDirective ())
 410                                 goto readnext;
 411                         else
 412                         {
 413                                 /* FIXME: find out a better way to do this check */
 414                                 if (File.fp != NULL)
 415                                         fsetpos (File.fp, &StartOfLine);
 416                                 else
 417                                         File.fpBufferPosition = bufferStartOfLine;
 418
 419                                 c = readNextChar ();
 420                         }
 421                 }
 422         }
 423
 424         if (c == EOF)
 425                 File.eof = TRUE;
 426         else if (c == NEWLINE)
 427         {
 428                 File.newLine = TRUE;
 429                 if (File.fp != NULL)            /* we have a file */
 430                         fgetpos (File.fp, &StartOfLine);
 431                 else                                            /* it's a buffer */
 432                         bufferStartOfLine = File.fpBufferPosition;
 433
 434         }
 435         else if (c == CRETURN)
 436         {
 437                 /*  Turn line breaks into a canonical form. The three commonly
 438                  *  used forms if line breaks: LF (UNIX), CR (MacIntosh), and
 439                  *  CR-LF (MS-DOS) are converted into a generic newline.
 440                  */
 441                 const int next = readNextChar ();  /* is CR followed by LF? */
 442
 443                 if (next != NEWLINE)
 444                         pushBackChar (next);
 445
 446                 c = NEWLINE;  /* convert CR into newline */
 447                 File.newLine = TRUE;
 448                 if (File.fp != NULL)
 449                         fgetpos (File.fp, &StartOfLine);
 450                 else
 451                         bufferStartOfLine = File.fpBufferPosition;
 452
 453         }
 454         DebugStatement ( debugPutc (DEBUG_RAW, c); )
 455         return c;
 456 }
 457
 458 extern void fileUngetc (int c)
 459 {
 460         File.ungetch = c;
 461 }
 462
 463 static vString *iFileGetLine (void)
 464 {
 465         vString *result = NULL;
 466         int c;
 467         if (File.line == NULL)
 468                 File.line = vStringNew ();
 469         vStringClear (File.line);
 470         do
 471         {
 472                 c = iFileGetc ();
 473                 if (c != EOF)
 474                         vStringPut (File.line, c);
 475                 if (c == '\n'  ||  (c == EOF  &&  vStringLength (File.line) > 0))
 476                 {
 477                         vStringTerminate (File.line);
 478 #ifdef HAVE_REGEX
 479                         if (vStringLength (File.line) > 0)
 480                                 matchRegex (File.line, File.source.language);
 481 #endif
 482                         result = File.line;
 483                         break;
 484                 }
 485         } while (c != EOF);
 486         Assert (result != NULL  ||  File.eof);
 487         return result;
 488 }
 489
 490 /*  Do not mix use of fileReadLine () and fileGetc () for the same file.
 491  */
 492 extern int fileGetc (void)
 493 {
 494         int c;
 495
 496         /*  If there is an ungotten character, then return it.  Don't do any
 497          *  other processing on it, though, because we already did that the
 498          *  first time it was read through fileGetc ().
 499          */
 500         if (File.ungetch != '\0')
 501         {
 502                 c = File.ungetch;
 503                 File.ungetch = '\0';
 504                 return c;  /* return here to avoid re-calling debugPutc () */
 505         }
 506         do
 507         {
 508                 if (File.currentLine != NULL)
 509                 {
 510                         c = *File.currentLine++;
 511                         if (c == '\0')
 512                                 File.currentLine = NULL;
 513                 }
 514                 else
 515                 {
 516                         vString* const line = iFileGetLine ();
 517                         if (line != NULL)
 518                                 File.currentLine = (unsigned char*) vStringValue (line);
 519                         if (File.currentLine == NULL)
 520                                 c = EOF;
 521                         else
 522                                 c = '\0';
 523                 }
 524         } while (c == '\0');
 525         DebugStatement ( debugPutc (DEBUG_READ, c); )
 526         return c;
 527 }
 528
 529 /*  An alternative interface to fileGetc (). Do not mix use of fileReadLine()
 530  *  and fileGetc() for the same file. The returned string does not contain
 531  *  the terminating newline. A NULL return value means that all lines in the
 532  *  file have been read and we are at the end of file.
 533  */
 534 extern const unsigned char *fileReadLine (void)
 535 {
 536         vString* const line = iFileGetLine ();
 537         const unsigned char* result = NULL;
 538         if (line != NULL)
 539         {
 540                 result = (const unsigned char*) vStringValue (line);
 541                 vStringStripNewline (line);
 542                 DebugStatement ( debugPrintf (DEBUG_READ, "%s\n", result); )
 543         }
 544         return result;
 545 }
 546
 547 /* Read a character choosing automatically between file or buffer, depending
 548  * on which mode we are.
 549  */
 550 static int readNextChar(void)
 551 {
 552         if (File.fp != NULL) {
 553                 return getc(File.fp);
 554         }
 555         else {
 556                 int c;
 557                 if (File.fpBufferPosition >= File.fpBufferSize)
 558                         return EOF;
 559
 560                 c = File.fpBuffer[File.fpBufferPosition];
 561                 File.fpBufferPosition++;
 562
 563                 return c;
 564         }
 565 }
 566
 567 /* Replaces ungetc() for file. In case of buffer we'll perform the same action:
 568  * fpBufferPosition-- and write of the param char into the buf.
 569  */
 570 static int pushBackChar (int c)
 571 {
 572
 573         if (File.fp != NULL) {
 574                 return ungetc (c, File.fp);
 575         }
 576         else {
 577                 File.fpBufferPosition--;
 578                 if (File.fpBufferPosition < 0)
 579                         return EOF;
 580                 File.fpBuffer[File.fpBufferPosition] = c;
 581                 return File.fpBuffer[File.fpBufferPosition];
 582         }
 583 }
 584
 585
 586 /* replacement for fsetpos, applied to a buffer */
 587 extern void setBufPos (int new_position)
 588 {
 589         File.fpBufferPosition = new_position;
 590 }
 591
 592 /* replacement for fgetpos, applied to a buffer */
 593 extern int getBufPos (void)
 594 {
 595         return File.fpBufferPosition;
 596 }
 597
 598 extern boolean useFile (void)
 599 {
 600         if (File.fp != NULL)
 601                 return TRUE;
 602         else
 603                 return FALSE;
 604 }
 605
 606
 607 /*
 608  *   Source file line reading with automatic buffer sizing
 609  *       Does not perform file/buffer checks. Only file is supported.
 610  */
 611 extern char *readLine (vString *const vLine, FILE *const fp)
 612 {
 613         char *result = NULL;
 614
 615         vStringClear (vLine);
 616         if (fp == NULL)  /* to free memory allocated to buffer */
 617                 error (FATAL, "NULL file pointer");
 618         else
 619         {
 620                 boolean reReadLine;
 621
 622                 /*  If reading the line places any character other than a null or a
 623                  *  newline at the last character position in the buffer (one less
 624                  *  than the buffer size), then we must resize the buffer and
 625                  *  reattempt to read the line.
 626                  */
 627                 do
 628                 {
 629                         char *const pLastChar = vStringValue (vLine) + vStringSize (vLine) -2;
 630                         fpos_t startOfLine;
 631
 632                         fgetpos (fp, &startOfLine);
 633                         reReadLine = FALSE;
 634                         *pLastChar = '\0';
 635                         result = fgets (vStringValue (vLine), (int) vStringSize (vLine), fp);
 636                         if (result == NULL)
 637                         {
 638                                 if (! feof (fp))
 639                                         error (FATAL | PERROR, "Failure on attempt to read file");
 640                         }
 641                         else if (*pLastChar != '\0'  &&
 642                                          *pLastChar != '\n'  &&  *pLastChar != '\r')
 643                         {
 644                                 /*  buffer overflow */
 645                                 reReadLine = vStringAutoResize (vLine);
 646                                 if (reReadLine)
 647                                         fsetpos (fp, &startOfLine);
 648                                 else
 649                                         error (FATAL | PERROR, "input line too big; out of memory");
 650                         }
 651                         else
 652                         {
 653                                 char* eol;
 654                                 vStringSetLength (vLine);
 655                                 /* canonicalize new line */
 656                                 eol = vStringValue (vLine) + vStringLength (vLine) - 1;
 657                                 if (*eol == '\r')
 658                                         *eol = '\n';
 659                                 else if (*(eol - 1) == '\r'  &&  *eol == '\n')
 660                                 {
 661                                         *(eol - 1) = '\n';
 662                                         *eol = '\0';
 663                                         --vLine->length;
 664                                 }
 665                         }
 666                 } while (reReadLine);
 667         }
 668         return result;
 669 }
 670
 671 /*  Places into the line buffer the contents of the line referenced by
 672  *  "location".
 673  */
 674 extern char *readSourceLine (
 675                 vString *const vLine, fpos_t location, long *const pSeekValue)
 676 {
 677         fpos_t orignalPosition;
 678         char *result;
 679
 680         fgetpos (File.fp, &orignalPosition);
 681         fsetpos (File.fp, &location);
 682         if (pSeekValue != NULL)
 683                 *pSeekValue = ftell (File.fp);
 684         result = readLine (vLine, File.fp);
 685         if (result == NULL)
 686                 error (FATAL, "Unexpected end of file: %s", vStringValue (File.name));
 687         fsetpos (File.fp, &orignalPosition);
 688
 689         return result;
 690 }
 691
 692 /* vi:set tabstop=4 shiftwidth=4: */