OpenSolaris_b135/tools/cscope-fast/main.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/* Copyright (c) 1988 AT&T */
/* All Rights Reserved */
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* cscope - interactive C symbol cross-reference
*
* main functions
*/
#include <curses.h> /* stdscr and TRUE */
#include <fcntl.h> /* O_RDONLY */
#include <sys/types.h> /* needed by stat.h */
#include <unistd.h> /* O_RDONLY */
#include <unistd.h> /* O_RDONLY */
#include <sys/stat.h> /* stat */
#include <libgen.h> /* O_RDONLY */
#include "global.h"
#include "version.h" /* FILEVERSION and FIXVERSION */
#include "vp.h" /* vpdirs and vpndirs */
#define OPTSEPS " \t" /* CSCOPEOPTION separators */
#define MINHOURS 4 /* minimum no activity timeout hours */
/* defaults for unset environment variables */
#define EDITOR "vi"
#define SHELL "sh"
#define TMPDIR "/tmp"
/*
* note: these digraph character frequencies were calculated from possible
* printable digraphs in the cross-reference for the C compiler
*/
char dichar1[] = " teisaprnl(of)=c"; /* 16 most frequent first chars */
char dichar2[] = " tnerpla"; /* 8 most frequent second chars */
/* using the above as first chars */
char dicode1[256]; /* digraph first character code */
char dicode2[256]; /* digraph second character code */
char *editor, *home, *shell; /* environment variables */
BOOL compress = YES; /* compress the characters in the crossref */
int cscopedepth; /* cscope invocation nesting depth */
char currentdir[PATHLEN + 1]; /* current directory */
BOOL dbtruncated; /* database symbols are truncated to 8 chars */
char **dbvpdirs; /* directories (including current) in */
/* database view path */
int dbvpndirs; /* # of directories in database view path */
int dispcomponents = 1; /* file path components to display */
BOOL editallprompt = YES; /* prompt between editing files */
int fileargc; /* file argument count */
char **fileargv; /* file argument values */
int fileversion; /* cross-reference file version */
BOOL incurses; /* in curses */
INVCONTROL invcontrol; /* inverted file control structure */
BOOL invertedindex; /* the database has an inverted index */
BOOL isuptodate; /* consider the crossref up-to-date */
BOOL linemode; /* use line oriented user interface */
char *namefile; /* file of file names */
char *newinvname; /* new inverted index file name */
char *newinvpost; /* new inverted index postings file name */
char *newreffile; /* new cross-reference file name */
FILE *newrefs; /* new cross-reference */
BOOL noacttimeout; /* no activity timeout occurred */
BOOL ogs; /* display OGS book and subsystem names */
FILE *postings; /* new inverted index postings */
char *prependpath; /* prepend path to file names */
BOOL returnrequired; /* RETURN required after selection number */
int symrefs = -1; /* cross-reference file */
char temp1[PATHLEN + 1]; /* temporary file name */
char temp2[PATHLEN + 1]; /* temporary file name */
long totalterms; /* total inverted index terms */
BOOL truncatesyms; /* truncate symbols to 8 characters */
static BOOL buildonly; /* only build the database */
static BOOL fileschanged; /* assume some files changed */
static char *invname = INVNAME; /* inverted index to the database */
static char *invpost = INVPOST; /* inverted index postings */
static unsigned noacttime; /* no activity timeout in seconds */
static BOOL onesearch; /* one search only in line mode */
static char *reffile = REFFILE; /* cross-reference file path name */
static char *reflines; /* symbol reference lines file */
static char *tmpdir; /* temporary directory */
static long traileroffset; /* file trailer offset */
static BOOL unconditional; /* unconditionally build database */
static void options(int argc, char **argv);
static void printusage(void);
static void removeindex(void);
static void cannotindex(void);
static void initcompress(void);
static void opendatabase(void);
static void closedatabase(void);
static void build(void);
static int compare(const void *s1, const void *s2);
static char *getoldfile(void);
static void putheader(char *dir);
static void putlist(char **names, int count);
static BOOL samelist(FILE *oldrefs, char **names, int count);
static void skiplist(FILE *oldrefs);
static void copydata(void);
static void copyinverted(void);
static void putinclude(char *s);
static void movefile(char *new, char *old);
static void timedout(int sig);
int
main(int argc, char **argv)
{
int envc; /* environment argument count */
char **envv; /* environment argument list */
FILE *names; /* name file pointer */
int oldnum; /* number in old cross-ref */
char path[PATHLEN + 1]; /* file path */
FILE *oldrefs; /* old cross-reference file */
char *s;
int c, i;
pid_t pid;
/* save the command name for messages */
argv0 = basename(argv[0]);
/* get the current directory for build() and line-oriented P command */
if (mygetwd(currentdir) == NULL) {
(void) fprintf(stderr,
"cscope: warning: cannot get current directory name\n");
(void) strcpy(currentdir, "<unknown>");
}
/* initialize any view path; (saves time since currendir is known) */
vpinit(currentdir);
dbvpndirs = vpndirs; /* number of directories in database view path */
/* directories (including current) in database view path */
dbvpdirs = vpdirs;
/* the first source directory is the current directory */
sourcedir(".");
/* read the environment */
editor = mygetenv("EDITOR", EDITOR);
editor = mygetenv("VIEWER", editor); /* use viewer if set */
home = getenv("HOME");
shell = mygetenv("SHELL", SHELL);
tmpdir = mygetenv("TMPDIR", TMPDIR);
/* increment nesting depth */
cscopedepth = atoi(mygetenv("CSCOPEDEPTH", "0"));
(void) sprintf(path, "CSCOPEDEPTH=%d", ++cscopedepth);
(void) putenv(stralloc(path));
if ((s = getenv("CSCOPEOPTIONS")) != NULL) {
/* parse the environment option string */
envc = 1;
envv = mymalloc(sizeof (char *));
s = strtok(stralloc(s), OPTSEPS);
while (s != NULL) {
envv = myrealloc(envv, ++envc * sizeof (char *));
envv[envc - 1] = stralloc(s);
s = strtok((char *)NULL, OPTSEPS);
}
/* set the environment options */
options(envc, envv);
}
/* set the command line options */
options(argc, argv);
/* create the temporary file names */
pid = getpid();
(void) sprintf(temp1, "%s/cscope%d.1", tmpdir, (int)pid);
(void) sprintf(temp2, "%s/cscope%d.2", tmpdir, (int)pid);
/* if running in the foreground */
if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
/* cleanup on the interrupt and quit signals */
(void) signal(SIGINT, myexit);
(void) signal(SIGQUIT, myexit);
}
/* cleanup on the hangup signal */
(void) signal(SIGHUP, myexit);
/* if the database path is relative and it can't be created */
if (reffile[0] != '/' && access(".", WRITE) != 0) {
/* if the database may not be up-to-date or can't be read */
(void) sprintf(path, "%s/%s", home, reffile);
if (isuptodate == NO || access(reffile, READ) != 0) {
/* put it in the home directory */
reffile = stralloc(path);
(void) sprintf(path, "%s/%s", home, invname);
invname = stralloc(path);
(void) sprintf(path, "%s/%s", home, invpost);
invpost = stralloc(path);
(void) fprintf(stderr,
"cscope: symbol database will be %s\n", reffile);
}
}
/* if the cross-reference is to be considered up-to-date */
if (isuptodate == YES) {
if ((oldrefs = vpfopen(reffile, "r")) == NULL) {
cannotopen(reffile);
exit(1);
}
/*
* get the crossref file version but skip the current
* directory
*/
if (fscanf(oldrefs, "cscope %d %*s", &fileversion) != 1) {
(void) fprintf(stderr,
"cscope: cannot read file version from file %s\n",
reffile);
exit(1);
}
if (fileversion >= 8) {
/* override these command line options */
compress = YES;
invertedindex = NO;
/* see if there are options in the database */
for (;;) {
/* no -q leaves multiple blanks */
while ((c = getc(oldrefs)) == ' ') {
;
}
if (c != '-') {
(void) ungetc(c, oldrefs);
break;
}
switch (c = getc(oldrefs)) {
case 'c': /* ASCII characters only */
compress = NO;
break;
case 'q': /* quick search */
invertedindex = YES;
(void) fscanf(oldrefs,
"%ld", &totalterms);
break;
case 'T':
/* truncate symbols to 8 characters */
dbtruncated = YES;
truncatesyms = YES;
break;
}
}
initcompress();
/* seek to the trailer */
if (fscanf(oldrefs, "%ld", &traileroffset) != 1) {
(void) fprintf(stderr,
"cscope: cannot read trailer offset from "
"file %s\n", reffile);
exit(1);
}
if (fseek(oldrefs, traileroffset, 0) != 0) {
(void) fprintf(stderr,
"cscope: cannot seek to trailer in "
"file %s\n", reffile);
exit(1);
}
}
/*
* read the view path for use in converting relative paths to
* full paths
*
* note: don't overwrite vp[n]dirs because this can cause
* the wrong database index files to be found in the viewpath
*/
if (fileversion >= 13) {
if (fscanf(oldrefs, "%d", &dbvpndirs) != 1) {
(void) fprintf(stderr,
"cscope: cannot read view path size from "
"file %s\n", reffile);
exit(1);
}
if (dbvpndirs > 0) {
dbvpdirs = mymalloc(
dbvpndirs * sizeof (char *));
for (i = 0; i < dbvpndirs; ++i) {
if (fscanf(oldrefs, "%s", path) != 1) {
(void) fprintf(stderr,
"cscope: cannot read view "
"path from file %s\n",
reffile);
exit(1);
}
dbvpdirs[i] = stralloc(path);
}
}
}
/* skip the source and include directory lists */
skiplist(oldrefs);
skiplist(oldrefs);
/* get the number of source files */
if (fscanf(oldrefs, "%d", &nsrcfiles) != 1) {
(void) fprintf(stderr,
"cscope: cannot read source file size from "
"file %s\n", reffile);
exit(1);
}
/* get the source file list */
srcfiles = mymalloc(nsrcfiles * sizeof (char *));
if (fileversion >= 9) {
/* allocate the string space */
if (fscanf(oldrefs, "%d", &oldnum) != 1) {
(void) fprintf(stderr,
"cscope: cannot read string space size "
"from file %s\n", reffile);
exit(1);
}
s = mymalloc(oldnum);
(void) getc(oldrefs); /* skip the newline */
/* read the strings */
if (fread(s, oldnum, 1, oldrefs) != 1) {
(void) fprintf(stderr,
"cscope: cannot read source file names "
"from file %s\n", reffile);
exit(1);
}
/* change newlines to nulls */
for (i = 0; i < nsrcfiles; ++i) {
srcfiles[i] = s;
for (++s; *s != '\n'; ++s) {
;
}
*s = '\0';
++s;
}
/* if there is a file of source file names */
if (namefile != NULL &&
(names = vpfopen(namefile, "r")) != NULL ||
(names = vpfopen(NAMEFILE, "r")) != NULL) {
/* read any -p option from it */
while (fscanf(names, "%s", path) == 1 &&
*path == '-') {
i = path[1];
s = path + 2; /* for "-Ipath" */
if (*s == '\0') {
/* if "-I path" */
(void) fscanf(names,
"%s", path);
s = path;
}
switch (i) {
case 'p':
/* file path components */
/* to display */
if (*s < '0' || *s > '9') {
(void) fprintf(stderr,
"cscope: -p option "
"in file %s: "
"missing or "
"invalid numeric "
"value\n",
namefile);
}
dispcomponents = atoi(s);
}
}
(void) fclose(names);
}
} else {
for (i = 0; i < nsrcfiles; ++i) {
if (fscanf(oldrefs, "%s", path) != 1) {
(void) fprintf(stderr,
"cscope: cannot read source file "
"name from file %s\n", reffile);
exit(1);
}
srcfiles[i] = stralloc(path);
}
}
(void) fclose(oldrefs);
} else {
/* get source directories from the environment */
if ((s = getenv("SOURCEDIRS")) != NULL) {
sourcedir(s);
}
/* make the source file list */
srcfiles = mymalloc(msrcfiles * sizeof (char *));
makefilelist();
if (nsrcfiles == 0) {
(void) fprintf(stderr,
"cscope: no source files found\n");
printusage();
exit(1);
}
/* get include directories from the environment */
if ((s = getenv("INCLUDEDIRS")) != NULL) {
includedir(s);
}
/* add /usr/include to the #include directory list */
includedir("/usr/include");
/* initialize the C keyword table */
initsymtab();
/* create the file name(s) used for a new cross-reference */
(void) strcpy(path, reffile);
s = basename(path);
*s = '\0';
(void) strcat(path, "n");
++s;
(void) strcpy(s, basename(reffile));
newreffile = stralloc(path);
(void) strcpy(s, basename(invname));
newinvname = stralloc(path);
(void) strcpy(s, basename(invpost));
newinvpost = stralloc(path);
/* build the cross-reference */
initcompress();
build();
if (buildonly == YES) {
exit(0);
}
}
opendatabase();
/*
* removing a database will not release the disk space if a cscope
* process has the file open, so a project may want unattended cscope
* processes to exit overnight, including their subshells and editors
*/
if (noacttime) {
(void) signal(SIGALRM, timedout);
(void) alarm(noacttime);
}
/*
* if using the line oriented user interface so cscope can be a
* subprocess to emacs or samuel
*/
if (linemode == YES) {
if (*pattern != '\0') { /* do any optional search */
if (search() == YES) {
while ((c = getc(refsfound)) != EOF) {
(void) putchar(c);
}
}
}
if (onesearch == YES) {
myexit(0);
}
for (;;) {
char buf[PATLEN + 2];
if (noacttime) {
(void) alarm(noacttime);
}
(void) printf(">> ");
(void) fflush(stdout);
if (fgets(buf, sizeof (buf), stdin) == NULL) {
myexit(0);
}
/* remove any trailing newline character */
if (*(s = buf + strlen(buf) - 1) == '\n') {
*s = '\0';
}
switch (*buf) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': /* samuel only */
field = *buf - '0';
(void) strcpy(pattern, buf + 1);
(void) search();
(void) printf("cscope: %d lines\n", totallines);
while ((c = getc(refsfound)) != EOF) {
(void) putchar(c);
}
break;
case 'c': /* toggle caseless mode */
case ctrl('C'):
if (caseless == NO) {
caseless = YES;
} else {
caseless = NO;
}
egrepcaseless(caseless);
break;
case 'r': /* rebuild database cscope style */
case ctrl('R'):
freefilelist();
makefilelist();
/* FALLTHROUGH */
case 'R': /* rebuild database samuel style */
rebuild();
(void) putchar('\n');
break;
case 'C': /* clear file names */
freefilelist();
(void) putchar('\n');
break;
case 'F': /* add a file name */
(void) strcpy(path, buf + 1);
if (infilelist(path) == NO &&
vpaccess(path, READ) == 0) {
addsrcfile(path);
}
(void) putchar('\n');
break;
case 'P': /* print the path to the files */
if (prependpath != NULL) {
(void) puts(prependpath);
} else {
(void) puts(currentdir);
}
break;
case 'q': /* quit */
case ctrl('D'):
case ctrl('Z'):
myexit(0);
default:
(void) fprintf(stderr,
"cscope: unknown command '%s'\n", buf);
break;
}
}
/* NOTREACHED */
}
/* pause before clearing the screen if there have been error messages */
if (errorsfound == YES) {
errorsfound = NO;
askforreturn();
}
(void) signal(SIGINT, SIG_IGN); /* ignore interrupts */
(void) signal(SIGPIPE, SIG_IGN); /* | command can cause pipe signal */
/* initialize the curses display package */
(void) initscr(); /* initialize the screen */
setfield(); /* set the initial cursor position */
entercurses();
(void) keypad(stdscr, TRUE); /* enable the keypad */
dispinit(); /* initialize display parameters */
putmsg(""); /* clear any build progress message */
display(); /* display the version number and input fields */
/* do any optional search */
if (*pattern != '\0') {
atfield(); /* move to the input field */
(void) command(ctrl('A')); /* search */
display(); /* update the display */
} else if (reflines != NULL) {
/* read any symbol reference lines file */
(void) readrefs(reflines);
display(); /* update the display */
}
for (;;) {
if (noacttime) {
(void) alarm(noacttime);
}
atfield(); /* move to the input field */
/* exit if the quit command is entered */
if ((c = mygetch()) == EOF || c == ctrl('D') ||
c == ctrl('Z')) {
break;
}
/* execute the commmand, updating the display if necessary */
if (command(c) == YES) {
display();
}
}
/* cleanup and exit */
myexit(0);
/* NOTREACHED */
return (0);
}
static void
options(int argc, char **argv)
{
char path[PATHLEN + 1]; /* file path */
int c;
char *s;
while (--argc > 0 && (*++argv)[0] == '-') {
for (s = argv[0] + 1; *s != '\0'; s++) {
/* look for an input field number */
if (isdigit(*s)) {
field = *s - '0';
if (*++s == '\0' && --argc > 0) {
s = *++argv;
}
if (strlen(s) > PATLEN) {
(void) fprintf(stderr,
"cscope: pattern too long, cannot "
"be > %d characters\n", PATLEN);
exit(1);
}
(void) strcpy(pattern, s);
goto nextarg;
}
switch (*s) {
case '-': /* end of options */
--argc;
++argv;
goto lastarg;
case 'V': /* print the version number */
(void) fprintf(stderr,
"%s: version %d%s\n", argv0,
FILEVERSION, FIXVERSION);
exit(0);
/*NOTREACHED*/
case 'b': /* only build the cross-reference */
buildonly = YES;
break;
case 'c': /* ASCII characters only in crossref */
compress = NO;
break;
case 'C':
/* turn on caseless mode for symbol searches */
caseless = YES;
/* simulate egrep -i flag */
egrepcaseless(caseless);
break;
case 'd': /* consider crossref up-to-date */
isuptodate = YES;
break;
case 'e': /* suppress ^E prompt between files */
editallprompt = NO;
break;
case 'L':
onesearch = YES;
/* FALLTHROUGH */
case 'l':
linemode = YES;
break;
case 'o':
/* display OGS book and subsystem names */
ogs = YES;
break;
case 'q': /* quick search */
invertedindex = YES;
break;
case 'r': /* display as many lines as possible */
returnrequired = YES;
break;
case 'T': /* truncate symbols to 8 characters */
truncatesyms = YES;
break;
case 'u':
/* unconditionally build the cross-reference */
unconditional = YES;
break;
case 'U': /* assume some files have changed */
fileschanged = YES;
break;
case 'f': /* alternate cross-reference file */
case 'F': /* symbol reference lines file */
case 'i': /* file containing file names */
case 'I': /* #include file directory */
case 'p': /* file path components to display */
case 'P': /* prepend path to file names */
case 's': /* additional source file directory */
case 'S':
case 't': /* no activity timeout in hours */
c = *s;
if (*++s == '\0' && --argc > 0) {
s = *++argv;
}
if (*s == '\0') {
(void) fprintf(stderr,
"%s: -%c option: missing or empty "
"value\n", argv0, c);
goto usage;
}
switch (c) {
case 'f':
/* alternate cross-reference file */
reffile = s;
(void) strcpy(path, s);
/* System V has a 14 character limit */
s = basename(path);
if ((int)strlen(s) > 11) {
s[11] = '\0';
}
s = path + strlen(path);
(void) strcpy(s, ".in");
invname = stralloc(path);
(void) strcpy(s, ".po");
invpost = stralloc(path);
break;
case 'F':
/* symbol reference lines file */
reflines = s;
break;
case 'i': /* file containing file names */
namefile = s;
break;
case 'I': /* #include file directory */
includedir(s);
break;
case 'p':
/* file path components to display */
if (*s < '0' || *s > '9') {
(void) fprintf(stderr,
"%s: -p option: missing "
"or invalid numeric "
"value\n", argv0);
goto usage;
}
dispcomponents = atoi(s);
break;
case 'P': /* prepend path to file names */
prependpath = s;
break;
case 's':
case 'S':
/* additional source directory */
sourcedir(s);
break;
case 't':
/* no activity timeout in hours */
if (*s < '1' || *s > '9') {
(void) fprintf(stderr,
"%s: -t option: missing or "
"invalid numeric value\n",
argv0);
goto usage;
}
c = atoi(s);
if (c < MINHOURS) {
(void) fprintf(stderr,
"cscope: minimum timeout "
"is %d hours\n", MINHOURS);
(void) sleep(3);
c = MINHOURS;
}
noacttime = c * 3600;
break;
}
goto nextarg;
default:
(void) fprintf(stderr,
"%s: unknown option: -%c\n", argv0, *s);
usage:
printusage();
exit(1);
}
}
nextarg: continue;
}
lastarg:
/* save the file arguments */
fileargc = argc;
fileargv = argv;
}
static void
printusage(void)
{
(void) fprintf(stderr,
"Usage: cscope [-bcdelLoqrtTuUV] [-f file] [-F file] [-i file] "
"[-I dir] [-s dir]\n");
(void) fprintf(stderr,
" [-p number] [-P path] [-[0-8] pattern] "
"[source files]\n");
(void) fprintf(stderr,
"-b Build the database only.\n");
(void) fprintf(stderr,
"-c Use only ASCII characters in the database file, "
"that is,\n");
(void) fprintf(stderr,
" do not compress the data.\n");
(void) fprintf(stderr,
"-d Do not update the database.\n");
(void) fprintf(stderr,
"-f \"file\" Use \"file\" as the database file name "
"instead of\n");
(void) fprintf(stderr,
" the default (cscope.out).\n");
(void) fprintf(stderr,
"-F \"file\" Read symbol reference lines from file, just\n");
/* BEGIN CSTYLED */
(void) fprintf(stderr,
" like the \"<\" command.\n");
/* END CSTYLED */
(void) fprintf(stderr,
"-i \"file\" Read any -I, -p, -q, and -T options and the\n");
(void) fprintf(stderr,
" list of source files from \"file\" instead of the \n");
(void) fprintf(stderr,
" default (cscope.files).\n");
(void) fprintf(stderr,
"-I \"dir\" Look in \"dir\" for #include files.\n");
(void) fprintf(stderr,
"-q Build an inverted index for quick symbol seaching.\n");
(void) fprintf(stderr,
"-s \"dir\" Look in \"dir\" for additional source files.\n");
}
static void
removeindex(void)
{
(void) fprintf(stderr,
"cscope: removed files %s and %s\n", invname, invpost);
(void) unlink(invname);
(void) unlink(invpost);
}
static void
cannotindex(void)
{
(void) fprintf(stderr,
"cscope: cannot create inverted index; ignoring -q option\n");
invertedindex = NO;
errorsfound = YES;
(void) fprintf(stderr,
"cscope: removed files %s and %s\n", newinvname, newinvpost);
(void) unlink(newinvname);
(void) unlink(newinvpost);
removeindex(); /* remove any existing index to prevent confusion */
}
void
cannotopen(char *file)
{
char msg[MSGLEN + 1];
(void) sprintf(msg, "Cannot open file %s", file);
putmsg(msg);
}
void
cannotwrite(char *file)
{
char msg[MSGLEN + 1];
(void) sprintf(msg, "Removed file %s because write failed", file);
myperror(msg); /* display the reason */
(void) unlink(file);
myexit(1); /* calls exit(2), which closes files */
}
/* set up the digraph character tables for text compression */
static void
initcompress(void)
{
int i;
if (compress == YES) {
for (i = 0; i < 16; ++i) {
dicode1[(unsigned)(dichar1[i])] = i * 8 + 1;
}
for (i = 0; i < 8; ++i) {
dicode2[(unsigned)(dichar2[i])] = i + 1;
}
}
}
/* open the database */
static void
opendatabase(void)
{
if ((symrefs = vpopen(reffile, O_RDONLY)) == -1) {
cannotopen(reffile);
myexit(1);
}
blocknumber = -1; /* force next seek to read the first block */
/* open any inverted index */
if (invertedindex == YES &&
invopen(&invcontrol, invname, invpost, INVAVAIL) == -1) {
askforreturn(); /* so user sees message */
invertedindex = NO;
}
}
/* close the database */
static void
closedatabase(void)
{
(void) close(symrefs);
if (invertedindex == YES) {
invclose(&invcontrol);
nsrcoffset = 0;
npostings = 0;
}
}
/* rebuild the database */
void
rebuild(void)
{
closedatabase();
build();
opendatabase();
/* revert to the initial display */
if (refsfound != NULL) {
(void) fclose(refsfound);
refsfound = NULL;
}
*lastfilepath = '\0'; /* last file may have new path */
}
/* build the cross-reference */
static void
build(void)
{
int i;
FILE *oldrefs; /* old cross-reference file */
time_t reftime; /* old crossref modification time */
char *file; /* current file */
char *oldfile; /* file in old cross-reference */
char newdir[PATHLEN + 1]; /* directory in new cross-reference */
char olddir[PATHLEN + 1]; /* directory in old cross-reference */
char oldname[PATHLEN + 1]; /* name in old cross-reference */
int oldnum; /* number in old cross-ref */
struct stat statstruct; /* file status */
int firstfile; /* first source file in pass */
int lastfile; /* last source file in pass */
int built = 0; /* built crossref for these files */
int copied = 0; /* copied crossref for these files */
BOOL interactive = YES; /* output progress messages */
/*
* normalize the current directory relative to the home directory so
* the cross-reference is not rebuilt when the user's login is moved
*/
(void) strcpy(newdir, currentdir);
if (strcmp(currentdir, home) == 0) {
(void) strcpy(newdir, "$HOME");
} else if (strncmp(currentdir, home, strlen(home)) == 0) {
(void) sprintf(newdir, "$HOME%s", currentdir + strlen(home));
}
/* sort the source file names (needed for rebuilding) */
qsort((char *)srcfiles, (unsigned)nsrcfiles, sizeof (char *), compare);
/*
* if there is an old cross-reference and its current directory
* matches or this is an unconditional build
*/
if ((oldrefs = vpfopen(reffile, "r")) != NULL && unconditional == NO &&
fscanf(oldrefs, "cscope %d %s", &fileversion, olddir) == 2 &&
(strcmp(olddir, currentdir) == 0 || /* remain compatible */
strcmp(olddir, newdir) == 0)) {
/* get the cross-reference file's modification time */
(void) fstat(fileno(oldrefs), &statstruct);
reftime = statstruct.st_mtime;
if (fileversion >= 8) {
BOOL oldcompress = YES;
BOOL oldinvertedindex = NO;
BOOL oldtruncatesyms = NO;
int c;
/* see if there are options in the database */
for (;;) {
while ((c = getc(oldrefs)) == ' ') {
}
if (c != '-') {
(void) ungetc(c, oldrefs);
break;
}
switch (c = getc(oldrefs)) {
case 'c': /* ASCII characters only */
oldcompress = NO;
break;
case 'q': /* quick search */
oldinvertedindex = YES;
(void) fscanf(oldrefs,
"%ld", &totalterms);
break;
case 'T':
/* truncate symbols to 8 characters */
oldtruncatesyms = YES;
break;
}
}
/* check the old and new option settings */
if (oldcompress != compress ||
oldtruncatesyms != truncatesyms) {
(void) fprintf(stderr,
"cscope: -c or -T option mismatch between "
"command line and old symbol database\n");
goto force;
}
if (oldinvertedindex != invertedindex) {
(void) fprintf(stderr,
"cscope: -q option mismatch between "
"command line and old symbol database\n");
if (invertedindex == NO) {
removeindex();
}
goto outofdate;
}
/* seek to the trailer */
if (fscanf(oldrefs, "%ld", &traileroffset) != 1 ||
fseek(oldrefs, traileroffset, 0) == -1) {
(void) fprintf(stderr,
"cscope: incorrect symbol database file "
"format\n");
goto force;
}
}
/* if assuming that some files have changed */
if (fileschanged == YES) {
goto outofdate;
}
/* see if the view path is the same */
if (fileversion >= 13 &&
samelist(oldrefs, vpdirs, vpndirs) == NO) {
goto outofdate;
}
/* see if the directory lists are the same */
if (samelist(oldrefs, srcdirs, nsrcdirs) == NO ||
samelist(oldrefs, incdirs, nincdirs) == NO ||
fscanf(oldrefs, "%d", &oldnum) != 1 ||
fileversion >= 9 && fscanf(oldrefs, "%*s") != 0) {
/* skip the string space size */
goto outofdate;
}
/*
* see if the list of source files is the same and
* none have been changed up to the included files
*/
for (i = 0; i < nsrcfiles; ++i) {
if (fscanf(oldrefs, "%s", oldname) != 1 ||
strnotequal(oldname, srcfiles[i]) ||
vpstat(srcfiles[i], &statstruct) != 0 ||
statstruct.st_mtime > reftime) {
goto outofdate;
}
}
/* the old cross-reference is up-to-date */
/* so get the list of included files */
while (i++ < oldnum && fscanf(oldrefs, "%s", oldname) == 1) {
addsrcfile(oldname);
}
(void) fclose(oldrefs);
return;
outofdate:
/* if the database format has changed, rebuild it all */
if (fileversion != FILEVERSION) {
(void) fprintf(stderr,
"cscope: converting to new symbol database file "
"format\n");
goto force;
}
/* reopen the old cross-reference file for fast scanning */
if ((symrefs = vpopen(reffile, O_RDONLY)) == -1) {
cannotopen(reffile);
myexit(1);
}
/* get the first file name in the old cross-reference */
blocknumber = -1;
(void) readblock(); /* read the first cross-ref block */
(void) scanpast('\t'); /* skip the header */
oldfile = getoldfile();
} else { /* force cross-referencing of all the source files */
force:
reftime = 0;
oldfile = NULL;
}
/* open the new cross-reference file */
if ((newrefs = fopen(newreffile, "w")) == NULL) {
cannotopen(newreffile);
myexit(1);
}
if (invertedindex == YES && (postings = fopen(temp1, "w")) == NULL) {
cannotopen(temp1);
cannotindex();
}
(void) fprintf(stderr, "cscope: building symbol database\n");
putheader(newdir);
fileversion = FILEVERSION;
if (buildonly == YES && !isatty(0)) {
interactive = NO;
} else {
initprogress();
}
/* output the leading tab expected by crossref() */
dbputc('\t');
/*
* make passes through the source file list until the last level of
* included files is processed
*/
firstfile = 0;
lastfile = nsrcfiles;
if (invertedindex == YES) {
srcoffset = mymalloc((nsrcfiles + 1) * sizeof (long));
}
for (;;) {
/* get the next source file name */
for (fileindex = firstfile; fileindex < lastfile; ++fileindex) {
/* display the progress about every three seconds */
if (interactive == YES && fileindex % 10 == 0) {
if (copied == 0) {
progress("%ld files built",
(long)built, 0L);
} else {
progress("%ld files built, %ld "
"files copied", (long)built,
(long)copied);
}
}
/* if the old file has been deleted get the next one */
file = srcfiles[fileindex];
while (oldfile != NULL && strcmp(file, oldfile) > 0) {
oldfile = getoldfile();
}
/*
* if there isn't an old database or this is
* a new file
*/
if (oldfile == NULL || strcmp(file, oldfile) < 0) {
crossref(file);
++built;
} else if (vpstat(file, &statstruct) == 0 &&
statstruct.st_mtime > reftime) {
/* if this file was modified */
crossref(file);
++built;
/*
* skip its old crossref so modifying the last
* source file does not cause all included files
* to be built. Unfortunately a new file that
* is alphabetically last will cause all
* included files to be built, but this is
* less likely
*/
oldfile = getoldfile();
} else { /* copy its cross-reference */
putfilename(file);
if (invertedindex == YES) {
copyinverted();
} else {
copydata();
}
++copied;
oldfile = getoldfile();
}
}
/* see if any included files were found */
if (lastfile == nsrcfiles) {
break;
}
firstfile = lastfile;
lastfile = nsrcfiles;
if (invertedindex == YES) {
srcoffset = myrealloc(srcoffset,
(nsrcfiles + 1) * sizeof (long));
}
/* sort the included file names */
qsort((char *)&srcfiles[firstfile],
(unsigned)(lastfile - firstfile), sizeof (char *), compare);
}
/* add a null file name to the trailing tab */
putfilename("");
dbputc('\n');
/* get the file trailer offset */
traileroffset = dboffset;
/*
* output the view path and source and include directory and
* file lists
*/
putlist(vpdirs, vpndirs);
putlist(srcdirs, nsrcdirs);
putlist(incdirs, nincdirs);
putlist(srcfiles, nsrcfiles);
if (fflush(newrefs) == EOF) {
/* rewind doesn't check for write failure */
cannotwrite(newreffile);
/* NOTREACHED */
}
/* create the inverted index if requested */
if (invertedindex == YES) {
char sortcommand[PATHLEN + 1];
if (fflush(postings) == EOF) {
cannotwrite(temp1);
/* NOTREACHED */
}
(void) fstat(fileno(postings), &statstruct);
(void) fprintf(stderr,
"cscope: building symbol index: temporary file size is "
"%ld bytes\n", statstruct.st_size);
(void) fclose(postings);
/*
* sort -T is broken until it is fixed we don't have too much choice
*/
/*
* (void) sprintf(sortcommand, "sort -y -T %s %s", tmpdir, temp1);
*/
(void) sprintf(sortcommand, "LC_ALL=C sort %s", temp1);
if ((postings = popen(sortcommand, "r")) == NULL) {
(void) fprintf(stderr,
"cscope: cannot open pipe to sort command\n");
cannotindex();
} else {
if ((totalterms = invmake(newinvname, newinvpost,
postings)) > 0) {
movefile(newinvname, invname);
movefile(newinvpost, invpost);
} else {
cannotindex();
}
(void) pclose(postings);
}
(void) unlink(temp1);
(void) free(srcoffset);
(void) fprintf(stderr,
"cscope: index has %ld references to %ld symbols\n",
npostings, totalterms);
}
/* rewrite the header with the trailer offset and final option list */
rewind(newrefs);
putheader(newdir);
(void) fclose(newrefs);
/* close the old database file */
if (symrefs >= 0) {
(void) close(symrefs);
}
if (oldrefs != NULL) {
(void) fclose(oldrefs);
}
/* replace it with the new database file */
movefile(newreffile, reffile);
}
/* string comparison function for qsort */
static int
compare(const void *s1, const void *s2)
{
return (strcmp((char *)s1, (char *)s2));
}
/* get the next file name in the old cross-reference */
static char *
getoldfile(void)
{
static char file[PATHLEN + 1]; /* file name in old crossref */
if (blockp != NULL) {
do {
if (*blockp == NEWFILE) {
skiprefchar();
getstring(file);
if (file[0] != '\0') {
/* if not end-of-crossref */
return (file);
}
return (NULL);
}
} while (scanpast('\t') != NULL);
}
return (NULL);
}
/*
* output the cscope version, current directory, database format options, and
* the database trailer offset
*/
static void
putheader(char *dir)
{
dboffset = fprintf(newrefs, "cscope %d %s", FILEVERSION, dir);
if (compress == NO) {
dboffset += fprintf(newrefs, " -c");
}
if (invertedindex == YES) {
dboffset += fprintf(newrefs, " -q %.10ld", totalterms);
} else {
/*
* leave space so if the header is overwritten without -q
* because writing the inverted index failed, the header is
* the same length
*/
dboffset += fprintf(newrefs, " ");
}
if (truncatesyms == YES) {
dboffset += fprintf(newrefs, " -T");
}
dbfprintf(newrefs, " %.10ld\n", traileroffset);
}
/* put the name list into the cross-reference file */
static void
putlist(char **names, int count)
{
int i, size = 0;
(void) fprintf(newrefs, "%d\n", count);
if (names == srcfiles) {
/* calculate the string space needed */
for (i = 0; i < count; ++i) {
size += strlen(names[i]) + 1;
}
(void) fprintf(newrefs, "%d\n", size);
}
for (i = 0; i < count; ++i) {
if (fputs(names[i], newrefs) == EOF ||
putc('\n', newrefs) == EOF) {
cannotwrite(newreffile);
/* NOTREACHED */
}
}
}
/* see if the name list is the same in the cross-reference file */
static BOOL
samelist(FILE *oldrefs, char **names, int count)
{
char oldname[PATHLEN + 1]; /* name in old cross-reference */
int oldcount;
int i;
/* see if the number of names is the same */
if (fscanf(oldrefs, "%d", &oldcount) != 1 ||
oldcount != count) {
return (NO);
}
/* see if the name list is the same */
for (i = 0; i < count; ++i) {
if (fscanf(oldrefs, "%s", oldname) != 1 ||
strnotequal(oldname, names[i])) {
return (NO);
}
}
return (YES);
}
/* skip the list in the cross-reference file */
static void
skiplist(FILE *oldrefs)
{
int i;
if (fscanf(oldrefs, "%d", &i) != 1) {
(void) fprintf(stderr,
"cscope: cannot read list size from file %s\n", reffile);
exit(1);
}
while (--i >= 0) {
if (fscanf(oldrefs, "%*s") != 0) {
(void) fprintf(stderr,
"cscope: cannot read list name from file %s\n",
reffile);
exit(1);
}
}
}
/* copy this file's symbol data */
static void
copydata(void)
{
char symbol[PATLEN + 1];
char *cp;
setmark('\t');
cp = blockp;
for (;;) {
/* copy up to the next \t */
do { /* innermost loop optimized to only one test */
while (*cp != '\t') {
dbputc(*cp++);
}
} while (*++cp == '\0' && (cp = readblock()) != NULL);
dbputc('\t'); /* copy the tab */
/* get the next character */
if (*(cp + 1) == '\0') {
cp = readblock();
}
/* exit if at the end of this file's data */
if (cp == NULL || *cp == NEWFILE) {
break;
}
/* look for an #included file */
if (*cp == INCLUDE) {
blockp = cp;
putinclude(symbol);
putstring(symbol);
setmark('\t');
cp = blockp;
}
}
blockp = cp;
}
/* copy this file's symbol data and output the inverted index postings */
static void
copyinverted(void)
{
char *cp;
int c;
int type; /* reference type (mark character) */
char symbol[PATLEN + 1];
/* note: this code was expanded in-line for speed */
/* while (scanpast('\n') != NULL) { */
/* other macros were replaced by code using cp instead of blockp */
cp = blockp;
for (;;) {
setmark('\n');
do { /* innermost loop optimized to only one test */
while (*cp != '\n') {
dbputc(*cp++);
}
} while (*++cp == '\0' && (cp = readblock()) != NULL);
dbputc('\n'); /* copy the newline */
/* get the next character */
if (*(cp + 1) == '\0') {
cp = readblock();
}
/* exit if at the end of this file's data */
if (cp == NULL) {
break;
}
switch (*cp) {
case '\n':
lineoffset = dboffset + 1;
continue;
case '\t':
dbputc('\t');
blockp = cp;
type = getrefchar();
switch (type) {
case NEWFILE: /* file name */
return;
case INCLUDE: /* #included file */
putinclude(symbol);
goto output;
}
dbputc(type);
skiprefchar();
getstring(symbol);
goto output;
}
c = *cp;
if (c & 0200) { /* digraph char? */
c = dichar1[(c & 0177) / 8];
}
/* if this is a symbol */
if (isalpha(c) || c == '_') {
blockp = cp;
getstring(symbol);
type = ' ';
output:
putposting(symbol, type);
putstring(symbol);
if (blockp == NULL) {
return;
}
cp = blockp;
}
}
blockp = cp;
}
/* process the #included file in the old database */
static void
putinclude(char *s)
{
dbputc(INCLUDE);
skiprefchar();
getstring(s);
incfile(s + 1, *s);
}
/* replace the old file with the new file */
static void
movefile(char *new, char *old)
{
(void) unlink(old);
if (link(new, old) == -1) {
(void) perror("cscope");
(void) fprintf(stderr,
"cscope: cannot link file %s to file %s\n", new, old);
myexit(1);
}
if (unlink(new) == -1) {
(void) perror("cscope");
(void) fprintf(stderr, "cscope: cannot unlink file %s\n", new);
errorsfound = YES;
}
}
/* enter curses mode */
void
entercurses(void)
{
incurses = YES;
(void) nonl(); /* don't translate an output \n to \n\r */
(void) cbreak(); /* single character input */
(void) noecho(); /* don't echo input characters */
(void) clear(); /* clear the screen */
initmouse(); /* initialize any mouse interface */
drawscrollbar(topline, nextline, totallines);
atfield();
}
/* exit curses mode */
void
exitcurses(void)
{
/* clear the bottom line */
(void) move(LINES - 1, 0);
(void) clrtoeol();
(void) refresh();
/* exit curses and restore the terminal modes */
(void) endwin();
incurses = NO;
/* restore the mouse */
cleanupmouse();
(void) fflush(stdout);
}
/* no activity timeout occurred */
static void
timedout(int sig)
{
/* if there is a child process, don't exit until it does */
if (childpid) {
closedatabase();
noacttimeout = YES;
return;
}
exitcurses();
(void) fprintf(stderr, "cscope: no activity for %d hours--exiting\n",
noacttime / 3600);
myexit(sig);
}
/* cleanup and exit */
void
myexit(int sig)
{
/* deleted layer causes multiple signals */
(void) signal(SIGHUP, SIG_IGN);
/* remove any temporary files */
if (temp1[0] != '\0') {
(void) unlink(temp1);
(void) unlink(temp2);
}
/* restore the terminal to its original mode */
if (incurses == YES) {
exitcurses();
}
/* dump core for debugging on the quit signal */
if (sig == SIGQUIT) {
(void) abort();
}
exit(sig);
}