mirror of
https://github.com/jart/cosmopolitan.git
synced 2024-05-02 11:48:44 +00:00
880 lines
22 KiB
C
880 lines
22 KiB
C
// clang-format off
|
|
/*
|
|
* $Id: entry.c 766 2010-09-11 18:59:45Z dhiebert $
|
|
*
|
|
* Copyright (c) 1996-2002, Darren Hiebert
|
|
*
|
|
* This source code is released for free distribution under the terms of the
|
|
* GNU General Public License.
|
|
*
|
|
* This module contains functions for creating tag entries.
|
|
*/
|
|
|
|
/*
|
|
* INCLUDE FILES
|
|
*/
|
|
#include "libc/runtime/runtime.h"
|
|
#include "third_party/ctags/general.h" /* must always come first */
|
|
|
|
#include "libc/mem/alg.h"
|
|
#include "libc/str/str.h"
|
|
#include "libc/str/str.h" /* to define isspace () */
|
|
#include "libc/errno.h"
|
|
|
|
#if defined (HAVE_SYS_TYPES_H)
|
|
#include "libc/calls/makedev.h"
|
|
#include "libc/calls/weirdtypes.h"
|
|
#include "libc/thread/thread.h"
|
|
#include "libc/calls/typedef/u.h"
|
|
#include "libc/calls/weirdtypes.h"
|
|
#include "libc/intrin/newbie.h"
|
|
#include "libc/sock/select.h"
|
|
#include "libc/sysv/consts/endian.h" /* to declare off_t on some hosts */
|
|
#endif
|
|
#if defined (HAVE_TYPES_H)
|
|
// MISSING #include <types.h> /* to declare off_t on some hosts */
|
|
#endif
|
|
#if defined (HAVE_UNISTD_H)
|
|
#include "libc/calls/calls.h"
|
|
#include "libc/calls/weirdtypes.h"
|
|
#include "libc/runtime/pathconf.h"
|
|
#include "libc/runtime/runtime.h"
|
|
#include "libc/runtime/sysconf.h"
|
|
#include "libc/sysv/consts/f.h"
|
|
#include "libc/sysv/consts/fileno.h"
|
|
#include "libc/sysv/consts/o.h"
|
|
#include "libc/sysv/consts/ok.h"
|
|
#include "libc/time/time.h"
|
|
#include "third_party/getopt/getopt.h"
|
|
#include "third_party/musl/crypt.h"
|
|
#include "third_party/musl/lockf.h" /* to declare close (), ftruncate (), truncate () */
|
|
#endif
|
|
|
|
/* These header files provide for the functions necessary to do file
|
|
* truncation.
|
|
*/
|
|
#ifdef HAVE_FCNTL_H
|
|
#include "libc/calls/calls.h"
|
|
#include "libc/calls/struct/flock.h"
|
|
#include "libc/calls/weirdtypes.h"
|
|
#include "libc/sysv/consts/at.h"
|
|
#include "libc/sysv/consts/f.h"
|
|
#include "libc/sysv/consts/fd.h"
|
|
#include "libc/sysv/consts/o.h"
|
|
#include "libc/sysv/consts/posix.h"
|
|
#include "libc/sysv/consts/s.h"
|
|
#endif
|
|
#ifdef HAVE_IO_H
|
|
// MISSING #include <io.h>
|
|
#endif
|
|
|
|
#include "third_party/ctags/debug.h"
|
|
#include "third_party/ctags/ctags.h"
|
|
#include "third_party/ctags/entry.h"
|
|
#include "third_party/ctags/main.h"
|
|
#include "third_party/ctags/options.h"
|
|
#include "third_party/ctags/read.h"
|
|
#include "third_party/ctags/routines.h"
|
|
#include "third_party/ctags/sort.h"
|
|
#include "third_party/ctags/strlist.h"
|
|
|
|
/*
|
|
* MACROS
|
|
*/
|
|
#define PSEUDO_TAG_PREFIX "!_"
|
|
|
|
#define includeExtensionFlags() (Option.tagFileFormat > 1)
|
|
|
|
/*
|
|
* Portability defines
|
|
*/
|
|
#if !defined(HAVE_TRUNCATE) && !defined(HAVE_FTRUNCATE) && !defined(HAVE_CHSIZE)
|
|
# define USE_REPLACEMENT_TRUNCATE
|
|
#endif
|
|
|
|
/* Hack for rediculous practice of Microsoft Visual C++.
|
|
*/
|
|
#if defined (WIN32) && defined (_MSC_VER)
|
|
# define chsize _chsize
|
|
# define open _open
|
|
# define close _close
|
|
# define O_RDWR _O_RDWR
|
|
#endif
|
|
|
|
/*
|
|
* DATA DEFINITIONS
|
|
*/
|
|
|
|
tagFile TagFile = {
|
|
NULL, /* tag file name */
|
|
NULL, /* tag file directory (absolute) */
|
|
NULL, /* file pointer */
|
|
{ 0, 0 }, /* numTags */
|
|
{ 0, 0, 0 }, /* max */
|
|
{ NULL, NULL, 0 }, /* etags */
|
|
NULL /* vLine */
|
|
};
|
|
|
|
static boolean TagsToStdout = FALSE;
|
|
|
|
/*
|
|
* FUNCTION PROTOTYPES
|
|
*/
|
|
#ifdef NEED_PROTO_TRUNCATE
|
|
extern int truncate (const char *path, off_t length);
|
|
#endif
|
|
|
|
#ifdef NEED_PROTO_FTRUNCATE
|
|
extern int ftruncate (int fd, off_t length);
|
|
#endif
|
|
|
|
/*
|
|
* FUNCTION DEFINITIONS
|
|
*/
|
|
|
|
extern void freeTagFileResources (void)
|
|
{
|
|
if (TagFile.directory != NULL)
|
|
eFree (TagFile.directory);
|
|
vStringDelete (TagFile.vLine);
|
|
}
|
|
|
|
extern const char *tagFileName (void)
|
|
{
|
|
return TagFile.name;
|
|
}
|
|
|
|
/*
|
|
* Pseudo tag support
|
|
*/
|
|
|
|
static void rememberMaxLengths (const size_t nameLength, const size_t lineLength)
|
|
{
|
|
if (nameLength > TagFile.max.tag)
|
|
TagFile.max.tag = nameLength;
|
|
|
|
if (lineLength > TagFile.max.line)
|
|
TagFile.max.line = lineLength;
|
|
}
|
|
|
|
static void writePseudoTag (
|
|
const char *const tagName,
|
|
const char *const fileName,
|
|
const char *const pattern)
|
|
{
|
|
const int length = fprintf (
|
|
TagFile.fp, "%s%s\t%s\t/%s/\n",
|
|
PSEUDO_TAG_PREFIX, tagName, fileName, pattern);
|
|
++TagFile.numTags.added;
|
|
rememberMaxLengths (strlen (tagName), (size_t) length);
|
|
}
|
|
|
|
static void addPseudoTags (void)
|
|
{
|
|
if (! Option.xref)
|
|
{
|
|
char format [11];
|
|
const char *formatComment = "unknown format";
|
|
|
|
sprintf (format, "%u", Option.tagFileFormat);
|
|
|
|
if (Option.tagFileFormat == 1)
|
|
formatComment = "original ctags format";
|
|
else if (Option.tagFileFormat == 2)
|
|
formatComment =
|
|
"extended format; --format=1 will not append ;\" to lines";
|
|
|
|
writePseudoTag ("TAG_FILE_FORMAT", format, formatComment);
|
|
writePseudoTag ("TAG_FILE_SORTED",
|
|
Option.sorted == SO_FOLDSORTED ? "2" :
|
|
(Option.sorted == SO_SORTED ? "1" : "0"),
|
|
"0=unsorted, 1=sorted, 2=foldcase");
|
|
writePseudoTag ("TAG_PROGRAM_AUTHOR", AUTHOR_NAME, AUTHOR_EMAIL);
|
|
writePseudoTag ("TAG_PROGRAM_NAME", PROGRAM_NAME, "");
|
|
writePseudoTag ("TAG_PROGRAM_URL", PROGRAM_URL, "official site");
|
|
writePseudoTag ("TAG_PROGRAM_VERSION", PROGRAM_VERSION, "");
|
|
}
|
|
}
|
|
|
|
static void updateSortedFlag (
|
|
const char *const line, FILE *const fp, fpos_t startOfLine)
|
|
{
|
|
const char *const tab = strchr (line, '\t');
|
|
|
|
if (tab != NULL)
|
|
{
|
|
const long boolOffset = tab - line + 1; /* where it should be */
|
|
|
|
if (line [boolOffset] == '0' || line [boolOffset] == '1')
|
|
{
|
|
fpos_t nextLine;
|
|
|
|
if (fgetpos (fp, &nextLine) == -1 || fsetpos (fp, &startOfLine) == -1)
|
|
error (WARNING, "Failed to update 'sorted' pseudo-tag");
|
|
else
|
|
{
|
|
fpos_t flagLocation;
|
|
int c, d;
|
|
|
|
do
|
|
c = fgetc (fp);
|
|
while (c != '\t' && c != '\n');
|
|
fgetpos (fp, &flagLocation);
|
|
d = fgetc (fp);
|
|
if (c == '\t' && (d == '0' || d == '1') &&
|
|
d != (int) Option.sorted)
|
|
{
|
|
fsetpos (fp, &flagLocation);
|
|
fputc (Option.sorted == SO_FOLDSORTED ? '2' :
|
|
(Option.sorted == SO_SORTED ? '1' : '0'), fp);
|
|
}
|
|
fsetpos (fp, &nextLine);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Look through all line beginning with "!_TAG_FILE", and update those which
|
|
* require it.
|
|
*/
|
|
static long unsigned int updatePseudoTags (FILE *const fp)
|
|
{
|
|
enum { maxEntryLength = 20 };
|
|
char entry [maxEntryLength + 1];
|
|
unsigned long linesRead = 0;
|
|
fpos_t startOfLine;
|
|
size_t entryLength;
|
|
const char *line;
|
|
|
|
sprintf (entry, "%sTAG_FILE", PSEUDO_TAG_PREFIX);
|
|
entryLength = strlen (entry);
|
|
Assert (entryLength < maxEntryLength);
|
|
|
|
fgetpos (fp, &startOfLine);
|
|
line = readLine (TagFile.vLine, fp);
|
|
while (line != NULL && line [0] == entry [0])
|
|
{
|
|
++linesRead;
|
|
if (strncmp (line, entry, entryLength) == 0)
|
|
{
|
|
char tab, classType [16];
|
|
|
|
if (sscanf (line + entryLength, "%15s%c", classType, &tab) == 2 &&
|
|
tab == '\t')
|
|
{
|
|
if (strcmp (classType, "_SORTED") == 0)
|
|
updateSortedFlag (line, fp, startOfLine);
|
|
}
|
|
fgetpos (fp, &startOfLine);
|
|
}
|
|
line = readLine (TagFile.vLine, fp);
|
|
}
|
|
while (line != NULL) /* skip to end of file */
|
|
{
|
|
++linesRead;
|
|
line = readLine (TagFile.vLine, fp);
|
|
}
|
|
return linesRead;
|
|
}
|
|
|
|
/*
|
|
* Tag file management
|
|
*/
|
|
|
|
static boolean isValidTagAddress (const char *const excmd)
|
|
{
|
|
boolean isValid = FALSE;
|
|
|
|
if (strchr ("/?", excmd [0]) != NULL)
|
|
isValid = TRUE;
|
|
else
|
|
{
|
|
char *address = xMalloc (strlen (excmd) + 1, char);
|
|
if (sscanf (excmd, "%[^;\n]", address) == 1 &&
|
|
strspn (address,"0123456789") == strlen (address))
|
|
isValid = TRUE;
|
|
eFree (address);
|
|
}
|
|
return isValid;
|
|
}
|
|
|
|
static boolean isCtagsLine (const char *const line)
|
|
{
|
|
enum fieldList { TAG, TAB1, SRC_FILE, TAB2, EXCMD, NUM_FIELDS };
|
|
boolean ok = FALSE; /* we assume not unless confirmed */
|
|
const size_t fieldLength = strlen (line) + 1;
|
|
char *const fields = xMalloc (NUM_FIELDS * fieldLength, char);
|
|
|
|
if (fields == NULL)
|
|
error (FATAL, "Cannot analyze tag file");
|
|
else
|
|
{
|
|
#define field(x) (fields + ((size_t) (x) * fieldLength))
|
|
|
|
const int numFields = sscanf (
|
|
line, "%[^\t]%[\t]%[^\t]%[\t]%[^\r\n]",
|
|
field (TAG), field (TAB1), field (SRC_FILE),
|
|
field (TAB2), field (EXCMD));
|
|
|
|
/* There must be exactly five fields: two tab fields containing
|
|
* exactly one tab each, the tag must not begin with "#", and the
|
|
* file name should not end with ";", and the excmd must be
|
|
* accceptable.
|
|
*
|
|
* These conditions will reject tag-looking lines like:
|
|
* int a; <C-comment>
|
|
* #define LABEL <C-comment>
|
|
*/
|
|
if (numFields == NUM_FIELDS &&
|
|
strlen (field (TAB1)) == 1 &&
|
|
strlen (field (TAB2)) == 1 &&
|
|
field (TAG) [0] != '#' &&
|
|
field (SRC_FILE) [strlen (field (SRC_FILE)) - 1] != ';' &&
|
|
isValidTagAddress (field (EXCMD)))
|
|
ok = TRUE;
|
|
|
|
eFree (fields);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
static boolean isEtagsLine (const char *const line)
|
|
{
|
|
boolean result = FALSE;
|
|
if (line [0] == '\f')
|
|
result = (boolean) (line [1] == '\n' || line [1] == '\r');
|
|
return result;
|
|
}
|
|
|
|
static boolean isTagFile (const char *const filename)
|
|
{
|
|
boolean ok = FALSE; /* we assume not unless confirmed */
|
|
FILE *const fp = fopen (filename, "rb");
|
|
|
|
if (fp == NULL && errno == ENOENT)
|
|
ok = TRUE;
|
|
else if (fp != NULL)
|
|
{
|
|
const char *line = readLine (TagFile.vLine, fp);
|
|
|
|
if (line == NULL)
|
|
ok = TRUE;
|
|
else
|
|
ok = (boolean) (isCtagsLine (line) || isEtagsLine (line));
|
|
fclose (fp);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
extern void copyBytes (FILE* const fromFp, FILE* const toFp, const long size)
|
|
{
|
|
enum { BufferSize = 1000 };
|
|
long toRead, numRead;
|
|
char* buffer = xMalloc (BufferSize, char);
|
|
long remaining = size;
|
|
do
|
|
{
|
|
toRead = (0 < remaining && remaining < BufferSize) ?
|
|
remaining : (long) BufferSize;
|
|
numRead = fread (buffer, (size_t) 1, (size_t) toRead, fromFp);
|
|
if (fwrite (buffer, (size_t)1, (size_t)numRead, toFp) < (size_t)numRead)
|
|
error (FATAL | PERROR, "cannot complete write");
|
|
if (remaining > 0)
|
|
remaining -= numRead;
|
|
} while (numRead == toRead && remaining != 0);
|
|
eFree (buffer);
|
|
}
|
|
|
|
extern void copyFile (const char *const from, const char *const to, const long size)
|
|
{
|
|
FILE* const fromFp = fopen (from, "rb");
|
|
if (fromFp == NULL)
|
|
error (FATAL | PERROR, "cannot open file to copy");
|
|
else
|
|
{
|
|
FILE* const toFp = fopen (to, "wb");
|
|
if (toFp == NULL)
|
|
error (FATAL | PERROR, "cannot open copy destination");
|
|
else
|
|
{
|
|
copyBytes (fromFp, toFp, size);
|
|
fclose (toFp);
|
|
}
|
|
fclose (fromFp);
|
|
}
|
|
}
|
|
|
|
extern void openTagFile (void)
|
|
{
|
|
setDefaultTagFileName ();
|
|
TagsToStdout = isDestinationStdout ();
|
|
|
|
if (TagFile.vLine == NULL)
|
|
TagFile.vLine = vStringNew ();
|
|
|
|
/* Open the tags file.
|
|
*/
|
|
if (TagsToStdout)
|
|
TagFile.fp = tempFile ("w", &TagFile.name);
|
|
else
|
|
{
|
|
boolean fileExists;
|
|
|
|
setDefaultTagFileName ();
|
|
TagFile.name = eStrdup (Option.tagFileName);
|
|
fileExists = doesFileExist (TagFile.name);
|
|
if (fileExists && ! isTagFile (TagFile.name))
|
|
error (FATAL,
|
|
"\"%s\" doesn't look like a tag file; I refuse to overwrite it.",
|
|
TagFile.name);
|
|
|
|
if (Option.etags)
|
|
{
|
|
if (Option.append && fileExists)
|
|
TagFile.fp = fopen (TagFile.name, "a+b");
|
|
else
|
|
TagFile.fp = fopen (TagFile.name, "w+b");
|
|
}
|
|
else
|
|
{
|
|
if (Option.append && fileExists)
|
|
{
|
|
TagFile.fp = fopen (TagFile.name, "r+");
|
|
if (TagFile.fp != NULL)
|
|
{
|
|
TagFile.numTags.prev = updatePseudoTags (TagFile.fp);
|
|
fclose (TagFile.fp);
|
|
TagFile.fp = fopen (TagFile.name, "a+");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TagFile.fp = fopen (TagFile.name, "w");
|
|
if (TagFile.fp != NULL)
|
|
addPseudoTags ();
|
|
}
|
|
}
|
|
if (TagFile.fp == NULL)
|
|
{
|
|
error (FATAL | PERROR, "cannot open tag file");
|
|
exit (1);
|
|
}
|
|
}
|
|
if (TagsToStdout)
|
|
TagFile.directory = eStrdup (CurrentDirectory);
|
|
else
|
|
TagFile.directory = absoluteDirname (TagFile.name);
|
|
}
|
|
|
|
#ifdef USE_REPLACEMENT_TRUNCATE
|
|
|
|
/* Replacement for missing library function.
|
|
*/
|
|
static int replacementTruncate (const char *const name, const long size)
|
|
{
|
|
char *tempName = NULL;
|
|
FILE *fp = tempFile ("w", &tempName);
|
|
fclose (fp);
|
|
copyFile (name, tempName, size);
|
|
copyFile (tempName, name, WHOLE_FILE);
|
|
remove (tempName);
|
|
eFree (tempName);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
static void sortTagFile (void)
|
|
{
|
|
if (TagFile.numTags.added > 0L)
|
|
{
|
|
if (Option.sorted != SO_UNSORTED)
|
|
{
|
|
verbose ("sorting tag file\n");
|
|
#ifdef EXTERNAL_SORT
|
|
externalSortTags (TagsToStdout);
|
|
#else
|
|
internalSortTags (TagsToStdout);
|
|
#endif
|
|
}
|
|
else if (TagsToStdout)
|
|
catFile (tagFileName ());
|
|
}
|
|
if (TagsToStdout)
|
|
remove (tagFileName ()); /* remove temporary file */
|
|
}
|
|
|
|
static void resizeTagFile (const long newSize)
|
|
{
|
|
int result;
|
|
|
|
#ifdef USE_REPLACEMENT_TRUNCATE
|
|
result = replacementTruncate (TagFile.name, newSize);
|
|
#else
|
|
# ifdef HAVE_TRUNCATE
|
|
result = truncate (TagFile.name, (off_t) newSize);
|
|
# else
|
|
const int fd = open (TagFile.name, O_RDWR);
|
|
|
|
if (fd == -1)
|
|
result = -1;
|
|
else
|
|
{
|
|
# ifdef HAVE_FTRUNCATE
|
|
result = ftruncate (fd, (off_t) newSize);
|
|
# else
|
|
# ifdef HAVE_CHSIZE
|
|
result = chsize (fd, newSize);
|
|
# endif
|
|
# endif
|
|
close (fd);
|
|
}
|
|
# endif
|
|
#endif
|
|
if (result == -1)
|
|
fprintf (errout, "Cannot shorten tag file: errno = %d\n", errno);
|
|
}
|
|
|
|
static void writeEtagsIncludes (FILE *const fp)
|
|
{
|
|
if (Option.etagsInclude)
|
|
{
|
|
unsigned int i;
|
|
for (i = 0 ; i < stringListCount (Option.etagsInclude) ; ++i)
|
|
{
|
|
vString *item = stringListItem (Option.etagsInclude, i);
|
|
fprintf (fp, "\f\n%s,include\n", vStringValue (item));
|
|
}
|
|
}
|
|
}
|
|
|
|
extern void closeTagFile (const boolean resize)
|
|
{
|
|
long desiredSize, size;
|
|
|
|
if (Option.etags)
|
|
writeEtagsIncludes (TagFile.fp);
|
|
desiredSize = ftell (TagFile.fp);
|
|
fseek (TagFile.fp, 0L, SEEK_END);
|
|
size = ftell (TagFile.fp);
|
|
fclose (TagFile.fp);
|
|
if (resize && desiredSize < size)
|
|
{
|
|
DebugStatement (
|
|
debugPrintf (DEBUG_STATUS, "shrinking %s from %ld to %ld bytes\n",
|
|
TagFile.name, size, desiredSize); )
|
|
resizeTagFile (desiredSize);
|
|
}
|
|
sortTagFile ();
|
|
eFree (TagFile.name);
|
|
TagFile.name = NULL;
|
|
}
|
|
|
|
extern void beginEtagsFile (void)
|
|
{
|
|
TagFile.etags.fp = tempFile ("w+b", &TagFile.etags.name);
|
|
TagFile.etags.byteCount = 0;
|
|
}
|
|
|
|
extern void endEtagsFile (const char *const name)
|
|
{
|
|
const char *line;
|
|
|
|
fprintf (TagFile.fp, "\f\n%s,%ld\n", name, (long) TagFile.etags.byteCount);
|
|
if (TagFile.etags.fp != NULL)
|
|
{
|
|
rewind (TagFile.etags.fp);
|
|
while ((line = readLine (TagFile.vLine, TagFile.etags.fp)) != NULL)
|
|
fputs (line, TagFile.fp);
|
|
fclose (TagFile.etags.fp);
|
|
remove (TagFile.etags.name);
|
|
eFree (TagFile.etags.name);
|
|
TagFile.etags.fp = NULL;
|
|
TagFile.etags.name = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Tag entry management
|
|
*/
|
|
|
|
/* This function copies the current line out to a specified file. It has no
|
|
* effect on the fileGetc () function. During copying, any '\' characters
|
|
* are doubled and a leading '^' or trailing '$' is also quoted. End of line
|
|
* characters (line feed or carriage return) are dropped.
|
|
*/
|
|
static size_t writeSourceLine (FILE *const fp, const char *const line)
|
|
{
|
|
size_t length = 0;
|
|
const char *p;
|
|
|
|
/* Write everything up to, but not including, a line end character.
|
|
*/
|
|
for (p = line ; *p != '\0' ; ++p)
|
|
{
|
|
const int next = *(p + 1);
|
|
const int c = *p;
|
|
|
|
if (c == CRETURN || c == NEWLINE)
|
|
break;
|
|
|
|
/* If character is '\', or a terminal '$', then quote it.
|
|
*/
|
|
if (c == BACKSLASH || c == (Option.backward ? '?' : '/') ||
|
|
(c == '$' && (next == NEWLINE || next == CRETURN)))
|
|
{
|
|
putc (BACKSLASH, fp);
|
|
++length;
|
|
}
|
|
putc (c, fp);
|
|
++length;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
/* Writes "line", stripping leading and duplicate white space.
|
|
*/
|
|
static size_t writeCompactSourceLine (FILE *const fp, const char *const line)
|
|
{
|
|
boolean lineStarted = FALSE;
|
|
size_t length = 0;
|
|
const char *p;
|
|
int c;
|
|
|
|
/* Write everything up to, but not including, the newline.
|
|
*/
|
|
for (p = line, c = *p ; c != NEWLINE && c != '\0' ; c = *++p)
|
|
{
|
|
if (lineStarted || ! isspace (c)) /* ignore leading spaces */
|
|
{
|
|
lineStarted = TRUE;
|
|
if (isspace (c))
|
|
{
|
|
int next;
|
|
|
|
/* Consume repeating white space.
|
|
*/
|
|
while (next = *(p+1) , isspace (next) && next != NEWLINE)
|
|
++p;
|
|
c = ' '; /* force space character for any white space */
|
|
}
|
|
if (c != CRETURN || *(p + 1) != NEWLINE)
|
|
{
|
|
putc (c, fp);
|
|
++length;
|
|
}
|
|
}
|
|
}
|
|
return length;
|
|
}
|
|
|
|
static int writeXrefEntry (const tagEntryInfo *const tag)
|
|
{
|
|
const char *const line =
|
|
readSourceLine (TagFile.vLine, tag->filePosition, NULL);
|
|
int length;
|
|
|
|
if (Option.tagFileFormat == 1)
|
|
length = fprintf (TagFile.fp, "%-16s %4lu %-16s ", tag->name,
|
|
tag->lineNumber, tag->sourceFileName);
|
|
else
|
|
length = fprintf (TagFile.fp, "%-16s %-10s %4lu %-16s ", tag->name,
|
|
tag->kindName, tag->lineNumber, tag->sourceFileName);
|
|
|
|
length += writeCompactSourceLine (TagFile.fp, line);
|
|
putc (NEWLINE, TagFile.fp);
|
|
++length;
|
|
|
|
return length;
|
|
}
|
|
|
|
/* Truncates the text line containing the tag at the character following the
|
|
* tag, providing a character which designates the end of the tag.
|
|
*/
|
|
static void truncateTagLine (
|
|
char *const line, const char *const token, const boolean discardNewline)
|
|
{
|
|
char *p = strstr (line, token);
|
|
|
|
if (p != NULL)
|
|
{
|
|
p += strlen (token);
|
|
if (*p != '\0' && ! (*p == '\n' && discardNewline))
|
|
++p; /* skip past character terminating character */
|
|
*p = '\0';
|
|
}
|
|
}
|
|
|
|
static int writeEtagsEntry (const tagEntryInfo *const tag)
|
|
{
|
|
int length;
|
|
|
|
if (tag->isFileEntry)
|
|
length = fprintf (TagFile.etags.fp, "\177%s\001%lu,0\n",
|
|
tag->name, tag->lineNumber);
|
|
else
|
|
{
|
|
long seekValue;
|
|
char *const line =
|
|
readSourceLine (TagFile.vLine, tag->filePosition, &seekValue);
|
|
|
|
if (tag->truncateLine)
|
|
truncateTagLine (line, tag->name, TRUE);
|
|
else
|
|
line [strlen (line) - 1] = '\0';
|
|
|
|
length = fprintf (TagFile.etags.fp, "%s\177%s\001%lu,%ld\n", line,
|
|
tag->name, tag->lineNumber, seekValue);
|
|
}
|
|
TagFile.etags.byteCount += length;
|
|
|
|
return length;
|
|
}
|
|
|
|
static int addExtensionFields (const tagEntryInfo *const tag)
|
|
{
|
|
const char* const kindKey = Option.extensionFields.kindKey ? "kind:" : "";
|
|
boolean first = TRUE;
|
|
const char* separator = ";\"";
|
|
const char* const empty = "";
|
|
int length = 0;
|
|
/* "sep" returns a value only the first time it is evaluated */
|
|
#define sep (first ? (first = FALSE, separator) : empty)
|
|
|
|
if (tag->kindName != NULL && (Option.extensionFields.kindLong ||
|
|
(Option.extensionFields.kind && tag->kind == '\0')))
|
|
length += fprintf (TagFile.fp,"%s\t%s%s", sep, kindKey, tag->kindName);
|
|
else if (tag->kind != '\0' && (Option.extensionFields.kind ||
|
|
(Option.extensionFields.kindLong && tag->kindName == NULL)))
|
|
length += fprintf (TagFile.fp, "%s\t%s%c", sep, kindKey, tag->kind);
|
|
|
|
if (Option.extensionFields.lineNumber)
|
|
length += fprintf (TagFile.fp, "%s\tline:%ld", sep, tag->lineNumber);
|
|
|
|
if (Option.extensionFields.language && tag->language != NULL)
|
|
length += fprintf (TagFile.fp, "%s\tlanguage:%s", sep, tag->language);
|
|
|
|
if (Option.extensionFields.scope &&
|
|
tag->extensionFields.scope [0] != NULL &&
|
|
tag->extensionFields.scope [1] != NULL)
|
|
length += fprintf (TagFile.fp, "%s\t%s:%s", sep,
|
|
tag->extensionFields.scope [0],
|
|
tag->extensionFields.scope [1]);
|
|
|
|
if (Option.extensionFields.typeRef &&
|
|
tag->extensionFields.typeRef [0] != NULL &&
|
|
tag->extensionFields.typeRef [1] != NULL)
|
|
length += fprintf (TagFile.fp, "%s\ttyperef:%s:%s", sep,
|
|
tag->extensionFields.typeRef [0],
|
|
tag->extensionFields.typeRef [1]);
|
|
|
|
if (Option.extensionFields.fileScope && tag->isFileScope)
|
|
length += fprintf (TagFile.fp, "%s\tfile:", sep);
|
|
|
|
if (Option.extensionFields.inheritance &&
|
|
tag->extensionFields.inheritance != NULL)
|
|
length += fprintf (TagFile.fp, "%s\tinherits:%s", sep,
|
|
tag->extensionFields.inheritance);
|
|
|
|
if (Option.extensionFields.access && tag->extensionFields.access != NULL)
|
|
length += fprintf (TagFile.fp, "%s\taccess:%s", sep,
|
|
tag->extensionFields.access);
|
|
|
|
if (Option.extensionFields.implementation &&
|
|
tag->extensionFields.implementation != NULL)
|
|
length += fprintf (TagFile.fp, "%s\timplementation:%s", sep,
|
|
tag->extensionFields.implementation);
|
|
|
|
if (Option.extensionFields.signature &&
|
|
tag->extensionFields.signature != NULL)
|
|
length += fprintf (TagFile.fp, "%s\tsignature:%s", sep,
|
|
tag->extensionFields.signature);
|
|
|
|
return length;
|
|
#undef sep
|
|
}
|
|
|
|
static int writePatternEntry (const tagEntryInfo *const tag)
|
|
{
|
|
char *const line = readSourceLine (TagFile.vLine, tag->filePosition, NULL);
|
|
const int searchChar = Option.backward ? '?' : '/';
|
|
boolean newlineTerminated;
|
|
int length = 0;
|
|
|
|
if (line == NULL)
|
|
error (FATAL, "bad tag in %s", vStringValue (File.name));
|
|
if (tag->truncateLine)
|
|
truncateTagLine (line, tag->name, FALSE);
|
|
newlineTerminated = (boolean) (line [strlen (line) - 1] == '\n');
|
|
|
|
length += fprintf (TagFile.fp, "%c^", searchChar);
|
|
length += writeSourceLine (TagFile.fp, line);
|
|
length += fprintf (TagFile.fp, "%s%c", newlineTerminated ? "$":"", searchChar);
|
|
|
|
return length;
|
|
}
|
|
|
|
static int writeLineNumberEntry (const tagEntryInfo *const tag)
|
|
{
|
|
return fprintf (TagFile.fp, "%lu", tag->lineNumber);
|
|
}
|
|
|
|
static int writeCtagsEntry (const tagEntryInfo *const tag)
|
|
{
|
|
int length = fprintf (TagFile.fp, "%s\t%s\t",
|
|
tag->name, tag->sourceFileName);
|
|
|
|
if (tag->lineNumberEntry)
|
|
length += writeLineNumberEntry (tag);
|
|
else
|
|
length += writePatternEntry (tag);
|
|
|
|
if (includeExtensionFlags ())
|
|
length += addExtensionFields (tag);
|
|
|
|
length += fprintf (TagFile.fp, "\n");
|
|
|
|
return length;
|
|
}
|
|
|
|
extern void makeTagEntry (const tagEntryInfo *const tag)
|
|
{
|
|
Assert (tag->name != NULL);
|
|
if (tag->name [0] == '\0')
|
|
error (WARNING, "ignoring null tag in %s", vStringValue (File.name));
|
|
else
|
|
{
|
|
int length = 0;
|
|
|
|
DebugStatement ( debugEntry (tag); )
|
|
if (Option.xref)
|
|
{
|
|
if (! tag->isFileEntry)
|
|
length = writeXrefEntry (tag);
|
|
}
|
|
else if (Option.etags)
|
|
length = writeEtagsEntry (tag);
|
|
else
|
|
length = writeCtagsEntry (tag);
|
|
|
|
++TagFile.numTags.added;
|
|
rememberMaxLengths (strlen (tag->name), (size_t) length);
|
|
DebugStatement ( fflush (TagFile.fp); )
|
|
}
|
|
}
|
|
|
|
extern void initTagEntry (tagEntryInfo *const e, const char *const name)
|
|
{
|
|
Assert (File.source.name != NULL);
|
|
memset (e, 0, sizeof (tagEntryInfo));
|
|
e->lineNumberEntry = (boolean) (Option.locate == EX_LINENUM);
|
|
e->lineNumber = getSourceLineNumber ();
|
|
e->language = getSourceLanguageName ();
|
|
e->filePosition = getInputFilePosition ();
|
|
e->sourceFileName = getSourceFileTagPath ();
|
|
e->name = name;
|
|
}
|
|
|
|
/* vi:set tabstop=4 shiftwidth=4: */
|