ctags/main/read.c

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