ctags/main/read.c

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