/**
* get_prefix: get as long prefix of the pattern as possible.
*
* @param[in] pattern
* @param[in] flags for gtags_first()
* @return prefix for search
*/
static char *
get_prefix(const char *pattern, int flags)
{
static char buffer[IDENTLEN];
char *prefix = buffer;
if (pattern == NULL || pattern[0] == 0) {
prefix = NULL;
} else if (!isregex(pattern)) {
if (flags & GTOP_IGNORECASE) {
buffer[0] = toupper(*pattern);
buffer[1] = 0;
} else {
prefix = NULL;
}
} else if (*pattern == '^') {
int save = 0;
char *p = (char *)(pattern + 1);
char *q = locatestring(p, ".*$", MATCH_AT_LAST);
if (!q)
q = locatestring(pattern, "$", MATCH_AT_LAST);
if (!q)
q = locatestring(pattern, ".*", MATCH_AT_LAST);
if (q) {
save = *q;
*q = 0;
}
if (*p == 0 || isregex(p)) {
prefix = NULL;
} else {
if (flags & GTOP_IGNORECASE) {
prefix[0] = toupper(*p);
prefix[1] = 0;
} else
strlimcpy(buffer, p, sizeof(buffer));
}
if (save)
*q = save;
}
return prefix;
}
/**
* gtags_first: return first record
*
* @param[in] gtop #GTOP structure
* @param[in] pattern tag name <br>
* - may be regular expression
* - may be @VAR{NULL}
* @param[in] flags #GTOP_PREFIX: prefix read <br>
* #GTOP_KEY: read key only <br>
* #GTOP_PATH: read path only <br>
* #GTOP_NOREGEX: don't use regular expression. <br>
* #GTOP_IGNORECASE: ignore case distinction. <br>
* #GTOP_BASICREGEX: use basic regular expression. <br>
* #GTOP_NOSORT: don't sort
* @return record
*/
GTP *
gtags_first(GTOP *gtop, const char *pattern, int flags)
{
int dbflags = 0;
int regflags = 0;
char prefix[IDENTLEN];
static regex_t reg;
regex_t *preg = ®
const char *key = NULL;
const char *tagline;
/* Settlement for last time if any */
if (gtop->path_hash) {
strhash_close(gtop->path_hash);
gtop->path_hash = NULL;
}
if (gtop->path_array) {
free(gtop->path_array);
gtop->path_array = NULL;
}
gtop->flags = flags;
if (flags & GTOP_PREFIX && pattern != NULL)
dbflags |= DBOP_PREFIX;
if (flags & GTOP_KEY)
dbflags |= DBOP_KEY;
if (!(flags & GTOP_BASICREGEX))
regflags |= REG_EXTENDED;
if (flags & GTOP_IGNORECASE)
regflags |= REG_ICASE;
/*
* Get key and compiled regular expression for dbop_xxxx().
*/
if (flags & GTOP_NOREGEX) {
key = pattern;
preg = NULL;
} else if (pattern == NULL || !strcmp(pattern, ".*")) {
/*
* Since the regular expression '.*' matches to any record,
* we take sequential read method.
*/
key = NULL;
preg = NULL;
} else if (isregex(pattern) && regcomp(preg, pattern, regflags) == 0) {
const char *p;
/*
* If the pattern include '^' + some non regular expression
* characters like '^aaa[0-9]', we take prefix read method
* with the non regular expression part as the prefix.
*/
if (!(flags & GTOP_IGNORECASE) && *pattern == '^' && *(p = pattern + 1) && !isregexchar(*p)) {
int i = 0;
while (*p && !isregexchar(*p) && i < IDENTLEN)
prefix[i++] = *p++;
prefix[i] = '\0';
key = prefix;
dbflags |= DBOP_PREFIX;
} else {
key = NULL;
}
} else {
key = pattern;
preg = NULL;
}
/*
* If GTOP_PATH is set, at first, we collect all path names in a pool and
* sort them. gtags_first() and gtags_next() returns one of the pool.
*/
if (gtop->flags & GTOP_PATH) {
struct sh_entry *entry;
char *p;
const char *cp;
unsigned long i;
gtop->path_hash = strhash_open(HASHBUCKETS);
/*
* Pool path names.
*
* fid path name
* +--------------------------
* |100 ./aaa/a.c
* |105 ./aaa/b.c
* ...
*/
for (tagline = dbop_first(gtop->dbop, key, preg, dbflags);
tagline != NULL;
tagline = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
/* extract file id */
p = locatestring(tagline, " ", MATCH_FIRST);
if (p == NULL)
die("Illegal tag record. '%s'\n", tagline);
*p = '\0';
entry = strhash_assign(gtop->path_hash, tagline, 1);
/* new entry: get path name and set. */
if (entry->value == NULL) {
cp = gpath_fid2path(tagline, NULL);
if (cp == NULL)
die("GPATH is corrupted.(file id '%s' not found)", tagline);
entry->value = strhash_strdup(gtop->path_hash, cp, 0);
}
}
/*
* Sort path names.
*
* fid path name path_array (sort)
* +-------------------------- +---+
* |100 ./aaa/a.c <-------* |
* |105 ./aaa/b.c <-------* |
* ... ...
*/
gtop->path_array = (char **)check_malloc(gtop->path_hash->entries * sizeof(char *));
i = 0;
for (entry = strhash_first(gtop->path_hash); entry != NULL; entry = strhash_next(gtop->path_hash))
gtop->path_array[i++] = entry->value;
if (i != gtop->path_hash->entries)
die("Something is wrong. 'i = %lu, entries = %lu'" , i, gtop->path_hash->entries);
if (!(gtop->flags & GTOP_NOSORT))
qsort(gtop->path_array, gtop->path_hash->entries, sizeof(char *), compare_path);
gtop->path_count = gtop->path_hash->entries;
gtop->path_index = 0;
if (gtop->path_index >= gtop->path_count)
return NULL;
gtop->gtp.path = gtop->path_array[gtop->path_index++];
return >op->gtp;
} else if (gtop->flags & GTOP_KEY) {
for (gtop->gtp.tag = dbop_first(gtop->dbop, key, preg, dbflags);
gtop->gtp.tag != NULL;
gtop->gtp.tag = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
break;
}
return gtop->gtp.tag ? >op->gtp : NULL;
} else {
if (gtop->vb == NULL)
gtop->vb = varray_open(sizeof(GTP), 200);
else
varray_reset(gtop->vb);
if (gtop->segment_pool == NULL)
gtop->segment_pool = pool_open();
else
pool_reset(gtop->segment_pool);
if (gtop->path_hash == NULL)
gtop->path_hash = strhash_open(HASHBUCKETS);
else
strhash_reset(gtop->path_hash);
tagline = dbop_first(gtop->dbop, key, preg, dbflags);
if (tagline == NULL)
return NULL;
/*
* Dbop_next() wil read the same record again.
*/
dbop_unread(gtop->dbop);
/*
* Read a tag segment with sorting.
*/
segment_read(gtop);
return >op->gtp_array[gtop->gtp_index++];
}
}
int
main(int argc, char **argv)
{
const char *av = NULL;
int db;
int optchar;
int option_index = 0;
while ((optchar = getopt_long(argc, argv, "ace:ifgGIlL:noOpPqrstTuvVx", long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
break;
case 'a':
aflag++;
break;
case 'c':
cflag++;
setcom(optchar);
break;
case 'e':
av = optarg;
break;
case 'f':
fflag++;
xflag++;
setcom(optchar);
break;
case 'g':
gflag++;
setcom(optchar);
break;
case 'G':
Gflag++;
break;
case 'i':
iflag++;
break;
case 'I':
Iflag++;
setcom(optchar);
break;
case 'l':
lflag++;
break;
case 'L':
file_list = optarg;
break;
case 'n':
nflag++;
if (optarg) {
if (!strcmp(optarg, "sort"))
nofilter |= SORT_FILTER;
else if (!strcmp(optarg, "path"))
nofilter |= PATH_FILTER;
} else {
nofilter = BOTH_FILTER;
}
break;
case 'o':
oflag++;
break;
case 'O':
Oflag++;
break;
case 'p':
pflag++;
setcom(optchar);
break;
case 'P':
Pflag++;
setcom(optchar);
break;
case 'q':
qflag++;
setquiet();
break;
case 'r':
rflag++;
break;
case 's':
sflag++;
break;
case 't':
tflag++;
break;
case 'T':
Tflag++;
break;
case 'u':
uflag++;
setcom(optchar);
break;
case 'v':
vflag++;
break;
case 'V':
Vflag++;
break;
case 'x':
xflag++;
break;
case ENCODE_PATH:
if (strlen(optarg) > 255)
die("too many encode chars.");
if (strchr(optarg, '/') || strchr(optarg, '.'))
die("cannot encode '/' and '.' in the path.");
set_encode_chars((unsigned char *)optarg);
break;
case FROM_HERE:
{
char *p = optarg;
const char *usage = "usage: global --from-here=lineno:path.";
context_lineno = p;
while (*p && isdigit(*p))
p++;
if (*p != ':')
die_with_code(2, usage);
*p++ = '\0';
if (!*p)
die_with_code(2, usage);
context_file = p;
}
break;
case RESULT:
if (!strcmp(optarg, "ctags-x"))
format = FORMAT_CTAGS_X;
else if (!strcmp(optarg, "ctags-xid"))
format = FORMAT_CTAGS_XID;
else if (!strcmp(optarg, "ctags"))
format = FORMAT_CTAGS;
else if (!strcmp(optarg, "path"))
format = FORMAT_PATH;
else if (!strcmp(optarg, "grep"))
format = FORMAT_GREP;
else if (!strcmp(optarg, "cscope"))
format = FORMAT_CSCOPE;
else
die_with_code(2, "unknown format type for the --result option.");
break;
default:
usage();
break;
}
}
if (qflag)
vflag = 0;
if (show_help)
help();
argc -= optind;
argv += optind;
/*
* At first, we pickup pattern from -e option. If it is not found
* then use argument which is not option.
*/
if (!av) {
av = *argv;
/*
* global -g pattern [files ...]
* av argv
*/
if (gflag && av)
argv++;
}
if (show_version)
version(av, vflag);
/*
* only -c, -u, -P and -p allows no argument.
*/
if (!av) {
switch (command) {
case 'c':
case 'u':
case 'p':
case 'P':
break;
case 'f':
if (file_list)
break;
default:
usage();
break;
}
}
/*
* -u and -p cannot have any arguments.
*/
if (av) {
switch (command) {
case 'u':
case 'p':
usage();
default:
break;
}
}
if (tflag)
xflag = 0;
if (nflag > 1)
nosource = 1; /* to keep compatibility */
if (print0)
set_print0();
/*
* remove leading blanks.
*/
if (!Iflag && !gflag && av)
for (; *av == ' ' || *av == '\t'; av++)
;
if (cflag && av && isregex(av))
die_with_code(2, "only name char is allowed with -c option.");
/*
* get path of following directories.
* o current directory
* o root of source tree
* o dbpath directory
*
* if GTAGS not found, getdbpath doesn't return.
*/
getdbpath(cwd, root, dbpath, (pflag && vflag));
/*
* print dbpath or rootdir.
*/
if (pflag) {
fprintf(stdout, "%s\n", (rflag) ? root : dbpath);
exit(0);
}
/*
* incremental update of tag files.
*/
if (uflag) {
STRBUF *sb = strbuf_open(0);
char *gtags = usable("gtags");
if (!gtags)
die("gtags command not found.");
if (chdir(root) < 0)
die("cannot change directory to '%s'.", root);
strbuf_puts(sb, gtags);
strbuf_puts(sb, " -i");
if (vflag)
strbuf_putc(sb, 'v');
strbuf_putc(sb, ' ');
strbuf_puts(sb, dbpath);
if (system(strbuf_value(sb)))
exit(1);
strbuf_close(sb);
exit(0);
}
/*
* complete function name
*/
if (cflag) {
if (Iflag)
completion_idutils(dbpath, root, av);
else
completion(dbpath, root, av);
exit(0);
}
/*
* make local prefix.
* local prefix must starts with './' and ends with '/'.
*/
if (lflag) {
STRBUF *sb = strbuf_open(0);
strbuf_putc(sb, '.');
if (strcmp(root, cwd) != 0) {
char *p = cwd + strlen(root);
if (*p != '/')
strbuf_putc(sb, '/');
strbuf_puts(sb, p);
}
strbuf_putc(sb, '/');
localprefix = check_strdup(strbuf_value(sb));
strbuf_close(sb);
#ifdef DEBUG
fprintf(stderr, "root=%s\n", root);
fprintf(stderr, "cwd=%s\n", cwd);
fprintf(stderr, "localprefix=%s\n", localprefix);
#endif
}
/*
* decide tag type.
*/
if (context_file) {
if (isregex(av))
die_with_code(2, "regular expression is not allowed with the --from-here option.");
db = decide_tag_by_context(av, context_file, atoi(context_lineno));
} else {
if (rflag && sflag)
db = GRTAGS + GSYMS;
else
db = (rflag) ? GRTAGS : ((sflag) ? GSYMS : GTAGS);
}
/*
* decide format.
* The --result option is given to priority more than the -t and -x option.
*/
if (format == 0) {
if (tflag) { /* ctags format */
format = FORMAT_CTAGS;
} else if (xflag) { /* print details */
format = FORMAT_CTAGS_X;
} else { /* print just a file name */
format = FORMAT_PATH;
}
}
/*
* decide path conversion type.
*/
if (nofilter & PATH_FILTER)
type = PATH_THROUGH;
else if (aflag)
type = PATH_ABSOLUTE;
else
type = PATH_RELATIVE;
/*
* exec lid(idutils).
*/
if (Iflag) {
chdir(root);
idutils(av, dbpath);
}
/*
* search pattern (regular expression).
*/
else if (gflag) {
chdir(root);
grep(av, argv, dbpath);
}
/*
* locate paths including the pattern.
*/
else if (Pflag) {
chdir(root);
pathlist(av, dbpath);
}
/*
* parse source files.
*/
else if (fflag) {
chdir(root);
parsefile(argv, cwd, root, dbpath, db);
}
/*
* tag search.
*/
else {
tagsearch(av, cwd, root, dbpath, db);
}
return 0;
}
int
search(const char *pattern, const char *root, const char *cwd, const char *dbpath, int db)
{
CONVERT *cv;
int count = 0;
GTOP *gtop;
GTP *gtp;
int flags = 0;
STRBUF *sb = NULL, *ib = NULL;
char curpath[MAXPATHLEN], curtag[IDENTLEN];
FILE *fp = NULL;
const char *src = "";
int lineno, last_lineno;
lineno = last_lineno = 0;
curpath[0] = curtag[0] = '\0';
/*
* open tag file.
*/
gtop = gtags_open(dbpath, root, db, GTAGS_READ, 0);
cv = convert_open(type, format, root, cwd, dbpath, stdout);
/*
* search through tag file.
*/
if (nofilter & SORT_FILTER)
flags |= GTOP_NOSORT;
if (iflag) {
if (!isregex(pattern)) {
sb = strbuf_open(0);
strbuf_putc(sb, '^');
strbuf_puts(sb, pattern);
strbuf_putc(sb, '$');
pattern = strbuf_value(sb);
}
flags |= GTOP_IGNORECASE;
}
if (Gflag)
flags |= GTOP_BASICREGEX;
if (format == FORMAT_PATH)
flags |= GTOP_PATH;
if (gtop->format & GTAGS_COMPACT)
ib = strbuf_open(0);
for (gtp = gtags_first(gtop, pattern, flags); gtp; gtp = gtags_next(gtop)) {
if (lflag && !locatestring(gtp->path, localprefix, MATCH_AT_FIRST))
continue;
if (format == FORMAT_PATH) {
convert_put_path(cv, gtp->path);
count++;
} else if (gtop->format & GTAGS_COMPACT) {
/*
* Compact format:
* a b
* tagline = <file id> <tag name> <line no>,...
*/
char *p = (char *)gtp->tagline;
const char *fid, *tagname;
int n = 0;
fid = p;
while (*p != ' ')
p++;
*p++ = '\0'; /* a */
tagname = p;
while (*p != ' ')
p++;
*p++ = '\0'; /* b */
/*
* Reopen or rewind source file.
*/
if (!nosource) {
if (strcmp(gtp->path, curpath) != 0) {
if (curpath[0] != '\0' && fp != NULL)
fclose(fp);
strlimcpy(curtag, tagname, sizeof(curtag));
strlimcpy(curpath, gtp->path, sizeof(curpath));
/*
* Use absolute path name to support GTAGSROOT
* environment variable.
*/
fp = fopen(makepath(root, curpath, NULL), "r");
if (fp == NULL)
warning("source file '%s' is not available.", curpath);
last_lineno = lineno = 0;
} else if (strcmp(gtp->tag, curtag) != 0) {
strlimcpy(curtag, gtp->tag, sizeof(curtag));
if (atoi(p) < last_lineno && fp != NULL) {
rewind(fp);
lineno = 0;
}
last_lineno = 0;
}
}
/*
* Unfold compact format.
*/
if (!isdigit(*p))
die("illegal compact format.");
if (gtop->format & GTAGS_COMPLINE) {
/*
*
* If GTAGS_COMPLINE flag is set, each line number is expressed as
* the difference from the previous line number except for the head.
* Please see flush_pool() in libutil/gtagsop.c for the details.
*/
int last = 0, cont = 0;
while (*p || cont > 0) {
if (cont > 0) {
n = last + 1;
if (n > cont) {
cont = 0;
continue;
}
} else if (isdigit(*p)) {
GET_NEXT_NUMBER(p);
} else if (*p == '-') {
GET_NEXT_NUMBER(p);
cont = n + last;
n = last + 1;
} else if (*p == ',') {
GET_NEXT_NUMBER(p);
n += last;
}
if (last_lineno != n && fp) {
while (lineno < n) {
if (!(src = strbuf_fgets(ib, fp, STRBUF_NOCRLF))) {
src = "";
fclose(fp);
fp = NULL;
break;
}
lineno++;
}
}
if (gtop->format & GTAGS_COMPNAME)
tagname = (char *)uncompress(tagname, gtp->tag);
convert_put_using(cv, tagname, gtp->path, n, src, fid);
count++;
last_lineno = last = n;
}
} else {
/*
* In fact, when GTAGS_COMPACT is set, GTAGS_COMPLINE is allways set.
* Therefore, the following code are not actually used.
* However, it is left for some test.
*/
while (*p) {
for (n = 0; isdigit(*p); p++)
n = n * 10 + *p - '0';
if (*p == ',')
p++;
if (last_lineno == n)
continue;
if (last_lineno != n && fp) {
while (lineno < n) {
if (!(src = strbuf_fgets(ib, fp, STRBUF_NOCRLF))) {
src = "";
fclose(fp);
fp = NULL;
break;
}
lineno++;
}
}
if (gtop->format & GTAGS_COMPNAME)
tagname = (char *)uncompress(tagname, gtp->tag);
convert_put_using(cv, tagname, gtp->path, n, src, fid);
count++;
last_lineno = n;
}
}
} else {
/*
* Standard format:
* a b c
* tagline = <file id> <tag name> <line no> <line image>
*/
char *p = (char *)gtp->tagline;
char namebuf[IDENTLEN];
const char *fid, *tagname, *image;
fid = p;
while (*p != ' ')
p++;
*p++ = '\0'; /* a */
tagname = p;
while (*p != ' ')
p++;
*p++ = '\0'; /* b */
if (gtop->format & GTAGS_COMPNAME) {
strlimcpy(namebuf, (char *)uncompress(tagname, gtp->tag), sizeof(namebuf));
tagname = namebuf;
}
if (nosource) {
image = " ";
} else {
while (*p != ' ')
p++;
image = p + 1; /* c + 1 */
if (gtop->format & GTAGS_COMPRESS)
image = (char *)uncompress(image, gtp->tag);
}
convert_put_using(cv, tagname, gtp->path, gtp->lineno, image, fid);
count++;
}
}
convert_close(cv);
if (sb)
strbuf_close(sb);
if (ib)
strbuf_close(ib);
if (fp)
fclose(fp);
gtags_close(gtop);
return count;
}
/**
* gtags_first: return first record
*
* @param[in] gtop #GTOP structure
* @param[in] pattern tag name <br>
* - may be regular expression
* - may be @VAR{NULL}
* @param[in] flags #GTOP_PREFIX: prefix read <br>
* #GTOP_KEY: read key only <br>
* #GTOP_PATH: read path only <br>
* #GTOP_NOREGEX: don't use regular expression. <br>
* #GTOP_IGNORECASE: ignore case distinction. <br>
* #GTOP_BASICREGEX: use basic regular expression. <br>
* #GTOP_NOSORT: don't sort
* @return record
*/
GTP *
gtags_first(GTOP *gtop, const char *pattern, int flags)
{
int regflags = 0;
static regex_t reg;
const char *tagline;
STATIC_STRBUF(regex);
strbuf_clear(regex);
gtop->preg = ®
gtop->key = NULL;
gtop->prefix = NULL;
gtop->flags = flags;
gtop->dbflags = 0;
gtop->readcount = 1;
/* Settlement for last time if any */
if (gtop->path_hash) {
strhash_close(gtop->path_hash);
gtop->path_hash = NULL;
}
if (gtop->path_array) {
free(gtop->path_array);
gtop->path_array = NULL;
}
if (flags & GTOP_KEY)
gtop->dbflags |= DBOP_KEY;
if (!(flags & GTOP_BASICREGEX))
regflags |= REG_EXTENDED;
/*
* decide a read method
*/
if (pattern == NULL)
gtop->preg = NULL;
else if (pattern[0] == 0)
return NULL;
else if (!strcmp(pattern, ".*") || !strcmp(pattern, "^.*$") ||
!strcmp(pattern, "^") || !strcmp(pattern, "$") ||
!strcmp(pattern, "^.*") || !strcmp(pattern, ".*$")) {
/*
* Since these regular expressions match to any record,
* we take sequential read method.
*/
gtop->preg = NULL;
} else if (flags & GTOP_IGNORECASE) {
regflags |= REG_ICASE;
if (!isregex(pattern) || flags & GTOP_NOREGEX) {
gtop->prefix = get_prefix(pattern, flags);
if (gtop->openflags & GTAGS_DEBUG)
if (gtop->prefix != NULL)
fprintf(stderr, "Using prefix: %s\n", gtop->prefix);
if (gtop->prefix == NULL)
die("gtags_first: impossible (1).");
strbuf_putc(regex, '^');
strbuf_puts(regex, pattern);
if (!(flags & GTOP_PREFIX))
strbuf_putc(regex, '$');
} else if (*pattern == '^' && (gtop->prefix = get_prefix(pattern, flags)) != NULL) {
if (gtop->openflags & GTAGS_DEBUG)
fprintf(stderr, "Using prefix: %s\n", gtop->prefix);
strbuf_puts(regex, pattern);
} else {
strbuf_puts(regex, pattern);
}
} else {
if (!isregex(pattern) || flags & GTOP_NOREGEX) {
if (flags & GTOP_PREFIX)
gtop->dbflags |= DBOP_PREFIX;
gtop->key = pattern;
gtop->preg = NULL;
} else if (*pattern == '^' && (gtop->key = get_prefix(pattern, flags)) != NULL) {
if (gtop->openflags & GTAGS_DEBUG)
fprintf(stderr, "Using prefix: %s\n", gtop->key);
gtop->dbflags |= DBOP_PREFIX;
gtop->preg = NULL;
} else {
strbuf_puts(regex, pattern);
}
}
if (gtop->prefix) {
if (gtop->key)
die("gtags_first: impossible (2).");
gtop->key = gtop->prefix;
gtop->dbflags |= DBOP_PREFIX;
}
if (strbuf_getlen(regex) > 0) {
if (gtop->preg == NULL)
die("gtags_first: impossible (3).");
if (regcomp(gtop->preg, strbuf_value(regex), regflags) != 0)
die("invalid regular expression.");
}
/*
* If GTOP_PATH is set, at first, we collect all path names in a pool and
* sort them. gtags_first() and gtags_next() returns one of the pool.
*/
if (gtop->flags & GTOP_PATH) {
struct sh_entry *entry;
char *p;
const char *cp;
unsigned long i;
gtop->path_hash = strhash_open(HASHBUCKETS);
/*
* Pool path names.
*
* fid path name
* +--------------------------
* |100 ./aaa/a.c
* |105 ./aaa/b.c
* ...
*/
again0:
for (tagline = dbop_first(gtop->dbop, gtop->key, gtop->preg, gtop->dbflags);
tagline != NULL;
tagline = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
/* extract file id */
p = locatestring(tagline, " ", MATCH_FIRST);
if (p == NULL)
die("Invalid tag record. '%s'\n", tagline);
*p = '\0';
entry = strhash_assign(gtop->path_hash, tagline, 1);
/* new entry: get path name and set. */
if (entry->value == NULL) {
cp = gpath_fid2path(tagline, NULL);
if (cp == NULL)
die("GPATH is corrupted.(file id '%s' not found)", tagline);
entry->value = strhash_strdup(gtop->path_hash, cp, 0);
}
}
if (gtop->prefix && gtags_restart(gtop))
goto again0;
/*
* Sort path names.
*
* fid path name path_array (sort)
* +-------------------------- +---+
* |100 ./aaa/a.c <-------* |
* |105 ./aaa/b.c <-------* |
* ... ...
*/
gtop->path_array = (char **)check_malloc(gtop->path_hash->entries * sizeof(char *));
i = 0;
for (entry = strhash_first(gtop->path_hash); entry != NULL; entry = strhash_next(gtop->path_hash))
gtop->path_array[i++] = entry->value;
if (i != gtop->path_hash->entries)
die("Something is wrong. 'i = %lu, entries = %lu'" , i, gtop->path_hash->entries);
if (!(gtop->flags & GTOP_NOSORT))
qsort(gtop->path_array, gtop->path_hash->entries, sizeof(char *), compare_path);
gtop->path_count = gtop->path_hash->entries;
gtop->path_index = 0;
if (gtop->path_index >= gtop->path_count)
return NULL;
gtop->gtp.path = gtop->path_array[gtop->path_index++];
return >op->gtp;
} else if (gtop->flags & GTOP_KEY) {
again1:
for (gtop->gtp.tag = dbop_first(gtop->dbop, gtop->key, gtop->preg, gtop->dbflags);
gtop->gtp.tag != NULL;
gtop->gtp.tag = dbop_next(gtop->dbop))
{
VIRTUAL_GRTAGS_GSYMS_PROCESSING(gtop);
break;
}
if (gtop->gtp.tag == NULL) {
if (gtop->prefix && gtags_restart(gtop))
goto again1;
}
return gtop->gtp.tag ? >op->gtp : NULL;
} else {
if (gtop->vb == NULL)
gtop->vb = varray_open(sizeof(GTP), 200);
else
varray_reset(gtop->vb);
if (gtop->segment_pool == NULL)
gtop->segment_pool = pool_open();
else
pool_reset(gtop->segment_pool);
if (gtop->path_hash == NULL)
gtop->path_hash = strhash_open(HASHBUCKETS);
else
strhash_reset(gtop->path_hash);
again2:
tagline = dbop_first(gtop->dbop, gtop->key, gtop->preg, gtop->dbflags);
if (tagline == NULL) {
if (gtop->prefix && gtags_restart(gtop))
goto again2;
return NULL;
}
/*
* Dbop_next() wil read the same record again.
*/
dbop_unread(gtop->dbop);
/*
* Read a tag segment with sorting.
*/
segment_read(gtop);
return >op->gtp_array[gtop->gtp_index++];
}
}
int
main(int argc, char **argv)
{
const char *av = NULL;
int db;
int optchar;
int option_index = 0;
int status = 0;
/*
* get path of following directories.
* o current directory
* o root of source tree
* o dbpath directory
*
* if GTAGS not found, exit with an error message.
*/
status = setupdbpath(0);
if (status == 0) {
cwd = get_cwd();
root = get_root();
dbpath = get_dbpath();
}
/*
* Setup GTAGSCONF and GTAGSLABEL environment variable
* according to the --gtagsconf and --gtagslabel option.
*/
preparse_options(argc, argv);
/*
* Open configuration file.
*/
openconf(root);
setenv_from_config();
logging_arguments(argc, argv);
while ((optchar = getopt_long(argc, argv, "acde:EifFgGIlL:MnoOpPqrsS:tTuvVx", long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
break;
case 'a':
aflag++;
break;
case 'c':
cflag++;
setcom(optchar);
break;
case 'd':
dflag++;
break;
case 'e':
av = optarg;
break;
case 'E':
Gflag = 0;
break;
case 'f':
fflag++;
xflag++;
setcom(optchar);
break;
case 'F':
Tflag = 0;
break;
case 'g':
gflag++;
setcom(optchar);
break;
case 'G':
Gflag++;
break;
case 'i':
iflag++;
break;
case 'I':
Iflag++;
setcom(optchar);
break;
case 'l':
Sflag++;
scope = ".";
break;
case 'L':
file_list = optarg;
break;
case 'M':
Mflag++;
iflag = 0;
break;
case 'n':
nflag++;
if (optarg) {
if (!strcmp(optarg, "sort"))
nofilter |= SORT_FILTER;
else if (!strcmp(optarg, "path"))
nofilter |= PATH_FILTER;
} else {
nofilter = BOTH_FILTER;
}
break;
case 'o':
oflag++;
break;
case 'O':
Oflag++;
break;
case 'p':
pflag++;
setcom(optchar);
break;
case 'P':
Pflag++;
setcom(optchar);
break;
case 'q':
qflag++;
setquiet();
break;
case 'r':
rflag++;
break;
case 's':
sflag++;
break;
case 'S':
Sflag++;
scope = optarg;
break;
case 't':
tflag++;
break;
case 'T':
Tflag++;
break;
case 'u':
uflag++;
setcom(optchar);
break;
case 'v':
vflag++;
setverbose();
break;
case 'V':
Vflag++;
break;
case 'x':
xflag++;
break;
case OPT_USE_COLOR:
if (optarg) {
if (!strcmp(optarg, "never"))
use_color = 0;
else if (!strcmp(optarg, "always"))
use_color = 1;
else if (!strcmp(optarg, "auto"))
use_color = 2;
else
die_with_code(2, "unknown color type.");
} else {
use_color = 2;
}
break;
case OPT_ENCODE_PATH:
encode_chars = optarg;
break;
case OPT_FROM_HERE:
{
char *p = optarg;
const char *usage = "usage: global --from-here=lineno:path.";
context_lineno = p;
while (*p && isdigit(*p))
p++;
if (*p != ':')
die_with_code(2, usage);
*p++ = '\0';
if (!*p)
die_with_code(2, usage);
context_file = p;
}
break;
case OPT_GTAGSCONF:
case OPT_GTAGSLABEL:
/* These options are already parsed in preparse_options() */
break;
case OPT_MATCH_PART:
if (!strcmp(optarg, "first"))
match_part = MATCH_PART_FIRST;
else if (!strcmp(optarg, "last"))
match_part = MATCH_PART_LAST;
else if (!strcmp(optarg, "all"))
match_part = MATCH_PART_ALL;
else
die_with_code(2, "unknown part type for the --match-part option.");
break;
case OPT_PATH_CONVERT:
do_path = 1;
if (!strcmp("absolute", optarg))
convert_type = PATH_ABSOLUTE;
else if (!strcmp("relative", optarg))
convert_type = PATH_RELATIVE;
else if (!strcmp("through", optarg))
convert_type = PATH_THROUGH;
else
die("Unknown path type.");
break;
case OPT_PATH_STYLE:
path_style = optarg;
break;
case OPT_RESULT:
if (!strcmp(optarg, "ctags-x"))
format = FORMAT_CTAGS_X;
else if (!strcmp(optarg, "ctags-xid"))
format = FORMAT_CTAGS_XID;
else if (!strcmp(optarg, "ctags"))
format = FORMAT_CTAGS;
else if (!strcmp(optarg, "ctags-mod"))
format = FORMAT_CTAGS_MOD;
else if (!strcmp(optarg, "path"))
format = FORMAT_PATH;
else if (!strcmp(optarg, "grep"))
format = FORMAT_GREP;
else if (!strcmp(optarg, "cscope"))
format = FORMAT_CSCOPE;
else
die_with_code(2, "unknown format type for the --result option.");
break;
case OPT_SINGLE_UPDATE:
single_update = optarg;
break;
default:
usage();
break;
}
}
if (qflag)
vflag = 0;
if (show_version)
version(av, vflag);
if (show_help)
help();
if (dbpath == NULL)
die_with_code(-status, gtags_dbpath_error);
/*
* decide format.
* The --result option is given to priority more than the -t and -x option.
*/
if (format == 0) {
if (tflag) { /* ctags format */
format = FORMAT_CTAGS;
} else if (xflag) { /* print details */
format = FORMAT_CTAGS_X;
} else { /* print just a file name */
format = FORMAT_PATH;
}
}
/*
* GTAGSBLANKENCODE will be used in less(1).
*/
switch (format) {
case FORMAT_CTAGS_X:
case FORMAT_CTAGS_XID:
if (encode_chars == NULL && getenv("GTAGSBLANKENCODE"))
encode_chars = " \t";
break;
}
if (encode_chars) {
if (strlen(encode_chars) > 255)
die("too many encode chars.");
if (strchr(encode_chars, '/') || strchr(encode_chars, '.'))
warning("cannot encode '/' and '.' in the path. Ignored.");
set_encode_chars((unsigned char *)encode_chars);
}
if (getenv("GTAGSTHROUGH"))
Tflag++;
if (use_color) {
#if defined(_WIN32) && !defined(__CYGWIN__)
if (!(getenv("ANSICON") || LoadLibrary("ANSI32.dll")) && use_color == 2)
use_color = 0;
#endif
if (use_color == 2 && !isatty(1))
use_color = 0;
if (Vflag)
use_color = 0;
}
argc -= optind;
argv += optind;
/*
* Path filter
*/
if (do_path) {
/*
* This code is needed for globash.rc.
* This code extract path name from tag line and
* replace it with the relative or the absolute path name.
*
* By default, if we are in src/ directory, the output
* should be converted like follows:
*
* main 10 ./src/main.c main(argc, argv)\n
* main 22 ./libc/func.c main(argc, argv)\n
* v
* main 10 main.c main(argc, argv)\n
* main 22 ../libc/func.c main(argc, argv)\n
*
* Similarly, the --path-convert=absolute option specified, then
* v
* main 10 /prj/xxx/src/main.c main(argc, argv)\n
* main 22 /prj/xxx/libc/func.c main(argc, argv)\n
*/
STRBUF *ib = strbuf_open(MAXBUFLEN);
CONVERT *cv;
char *ctags_x;
if (argc < 3)
die("global --path-convert: 3 arguments needed.");
cv = convert_open(convert_type, FORMAT_CTAGS_X, argv[0], argv[1], argv[2], stdout, NOTAGS);
while ((ctags_x = strbuf_fgets(ib, stdin, STRBUF_NOCRLF)) != NULL)
convert_put(cv, ctags_x);
convert_close(cv);
strbuf_close(ib);
exit(0);
}
/*
* At first, we pickup pattern from -e option. If it is not found
* then use argument which is not option.
*/
if (!av) {
av = *argv;
/*
* global -g pattern [files ...]
* av argv
*/
if (gflag && av)
argv++;
}
if (single_update) {
if (command == 0) {
uflag++;
command = 'u';
} else if (command != 'u') {
; /* ignored */
}
}
/*
* only -c, -u, -P and -p allows no argument.
*/
if (!av) {
switch (command) {
case 'c':
case 'u':
case 'p':
case 'P':
break;
case 'f':
if (file_list)
break;
default:
usage();
break;
}
}
/*
* -u and -p cannot have any arguments.
*/
if (av) {
switch (command) {
case 'u':
case 'p':
usage();
default:
break;
}
}
if (tflag)
xflag = 0;
if (nflag > 1)
nosource = 1; /* to keep compatibility */
if (print0)
set_print0();
if (cflag && match_part == 0)
match_part = MATCH_PART_ALL;
/*
* remove leading blanks.
*/
if (!Iflag && !gflag && av)
for (; *av == ' ' || *av == '\t'; av++)
;
if (cflag && !Pflag && av && isregex(av))
die_with_code(2, "only name char is allowed with -c option.");
/*
* print dbpath or rootdir.
*/
if (pflag) {
fprintf(stdout, "%s\n", (rflag) ? root : dbpath);
exit(0);
}
/*
* incremental update of tag files.
*/
if (uflag) {
STRBUF *sb = strbuf_open(0);
char *gtags_path = usable("gtags");
if (!gtags_path)
die("gtags command not found.");
if (chdir(root) < 0)
die("cannot change directory to '%s'.", root);
#if defined(_WIN32) && !defined(__CYGWIN__)
/*
* Get around CMD.EXE's weird quoting rules by sticking another
* perceived whitespace in front (also works with Take Command).
*/
strbuf_putc(sb, ';');
#endif
strbuf_puts(sb, quote_shell(gtags_path));
strbuf_puts(sb, " -i");
if (vflag)
strbuf_puts(sb, " -v");
if (single_update) {
if (!isabspath(single_update)) {
static char regular_path_name[MAXPATHLEN];
if (rel2abs(single_update, cwd, regular_path_name, sizeof(regular_path_name)) == NULL)
die("rel2abs failed.");
single_update = regular_path_name;
}
strbuf_puts(sb, " --single-update ");
strbuf_puts(sb, quote_shell(single_update));
}
strbuf_putc(sb, ' ');
strbuf_puts(sb, quote_shell(dbpath));
if (system(strbuf_value(sb)))
exit(1);
strbuf_close(sb);
exit(0);
}
/*
* decide tag type.
*/
if (context_file) {
if (isregex(av))
die_with_code(2, "regular expression is not allowed with the --from-here option.");
db = decide_tag_by_context(av, context_file, atoi(context_lineno));
} else {
if (dflag)
db = GTAGS;
else if (rflag && sflag)
db = GRTAGS + GSYMS;
else
db = (rflag) ? GRTAGS : ((sflag) ? GSYMS : GTAGS);
}
/*
* complete function name
*/
if (cflag) {
if (Iflag)
completion_idutils(dbpath, root, av);
else if (Pflag)
completion_path(dbpath, av);
else
completion(dbpath, root, av, db);
exit(0);
}
/*
* make local prefix.
* local prefix must starts with './' and ends with '/'.
*/
if (Sflag) {
STRBUF *sb = strbuf_open(0);
static char buf[MAXPATHLEN];
const char *path = scope;
/*
* normalize the path of scope directory.
*/
if (!test("d", path))
die("'%s' not found or not a directory.", scope);
if (!isabspath(path))
path = makepath(cwd, path, NULL);
if (realpath(path, buf) == NULL)
die("cannot get real path of '%s'.", scope);
if (!in_the_project(buf))
die("'%s' is out of the source project.", scope);
scope = buf;
/*
* make local prefix.
*/
strbuf_putc(sb, '.');
if (strcmp(root, scope) != 0) {
const char *p = scope + strlen(root);
if (*p != '/')
strbuf_putc(sb, '/');
strbuf_puts(sb, p);
}
strbuf_putc(sb, '/');
localprefix = check_strdup(strbuf_value(sb));
strbuf_close(sb);
#ifdef DEBUG
fprintf(stderr, "root=%s\n", root);
fprintf(stderr, "cwd=%s\n", cwd);
fprintf(stderr, "localprefix=%s\n", localprefix);
#endif
}
/*
* convert the file-list path into an absolute path.
*/
if (file_list && strcmp(file_list, "-") && !isabspath(file_list)) {
static char buf[MAXPATHLEN];
if (realpath(file_list, buf) == NULL)
die("'%s' not found.", file_list);
file_list = buf;
}
/*
* decide path conversion type.
*/
if (nofilter & PATH_FILTER)
type = PATH_THROUGH;
else if (aflag)
type = PATH_ABSOLUTE;
else
type = PATH_RELATIVE;
if (path_style) {
if (!strcmp(path_style, "relative"))
type = PATH_RELATIVE;
else if (!strcmp(path_style, "absolute"))
type = PATH_ABSOLUTE;
else if (!strcmp(path_style, "through"))
type = PATH_THROUGH;
else if (!strcmp(path_style, "shorter"))
type = PATH_SHORTER;
else if (!strcmp(path_style, "abslib")) {
type = PATH_RELATIVE;
abslib++;
} else
die("invalid path style.");
}
/*
* exec lid(idutils).
*/
if (Iflag) {
chdir(root);
idutils(av, dbpath);
}
/*
* search pattern (regular expression).
*/
else if (gflag) {
chdir(root);
grep(av, argv, dbpath);
}
/*
* locate paths including the pattern.
*/
else if (Pflag) {
chdir(root);
pathlist(av, dbpath);
}
/*
* parse source files.
*/
else if (fflag) {
chdir(root);
parsefile(argv, cwd, root, dbpath, db);
}
/*
* tag search.
*/
else {
tagsearch(av, cwd, root, dbpath, db);
}
return 0;
}
/**
* tagsearch: execute tag search
*
* @param[in] pattern search pattern
* @param[in] cwd current directory
* @param[in] root root of source tree
* @param[in] dbpath database directory
* @param[in] db #GTAGS,#GRTAGS,#GSYMS
*/
void
tagsearch(const char *pattern, const char *cwd, const char *root, const char *dbpath, int db)
{
int count, total = 0;
char buffer[IDENTLEN], *p = buffer;
char libdbpath[MAXPATHLEN];
/*
* trim pattern (^<no regex>$ => <no regex>)
*/
if (pattern) {
strlimcpy(p, pattern, sizeof(buffer));
if (*p++ == '^') {
char *q = p + strlen(p);
if (*--q == '$') {
*q = 0;
if (*p == 0 || !isregex(p))
pattern = p;
}
}
}
/*
* search in current source tree.
*/
count = search(pattern, root, cwd, dbpath, db);
total += count;
/*
* search in library path.
*/
if (abslib)
type = PATH_ABSOLUTE;
if (db == GTAGS && getenv("GTAGSLIBPATH") && (count == 0 || Tflag) && !Sflag) {
STRBUF *sb = strbuf_open(0);
char *libdir, *nextp = NULL;
strbuf_puts(sb, getenv("GTAGSLIBPATH"));
/*
* search for each tree in the library path.
*/
for (libdir = strbuf_value(sb); libdir; libdir = nextp) {
if ((nextp = locatestring(libdir, PATHSEP, MATCH_FIRST)) != NULL)
*nextp++ = 0;
if (!gtagsexist(libdir, libdbpath, sizeof(libdbpath), 0))
continue;
if (!strcmp(dbpath, libdbpath))
continue;
if (!test("f", makepath(libdbpath, dbname(db), NULL)))
continue;
/*
* search again
*/
count = search(pattern, libdir, cwd, libdbpath, db);
total += count;
if (count > 0 && !Tflag) {
/* for verbose message */
dbpath = libdbpath;
break;
}
}
strbuf_close(sb);
}
if (vflag) {
print_count(total);
if (!Tflag)
fprintf(stderr, " (using '%s')", makepath(dbpath, dbname(db), NULL));
fputs(".\n", stderr);
}
}
/**
* idutils: @NAME{lid}(@NAME{idutils}) pattern
*
* @param[in] pattern @NAME{POSIX} regular expression
* @param[in] dbpath @FILE{GTAGS} directory
*/
void
idutils(const char *pattern, const char *dbpath)
{
FILE *ip;
CONVERT *cv;
STRBUF *ib = strbuf_open(0);
char encoded_pattern[IDENTLEN];
char path[MAXPATHLEN];
const char *lid;
int linenum, count;
char *p, *q, *grep;
lid = usable("lid");
if (!lid)
die("lid(idutils) not found.");
if (!test("f", makepath(dbpath, "ID", NULL)))
die("ID file not found.");
/*
* convert spaces into %FF format.
*/
encode(encoded_pattern, sizeof(encoded_pattern), pattern);
/*
* make lid command line.
* Invoke lid with the --result=grep option to generate grep format.
*/
#if _WIN32 || __DJGPP__
strbuf_puts(ib, lid);
#else
strbuf_sprintf(ib, "PWD=%s %s", quote_shell(root), lid);
#endif
strbuf_sprintf(ib, " --file=%s/ID", quote_shell(dbpath));
strbuf_puts(ib, " --separator=newline");
if (format == FORMAT_PATH)
strbuf_puts(ib, " --result=filenames --key=none");
else
strbuf_puts(ib, " --result=grep");
if (iflag)
strbuf_puts(ib, " --ignore-case");
if (isregex(pattern))
strbuf_puts(ib, " --regexp");
strbuf_putc(ib, ' ');
strbuf_puts(ib, quote_shell(pattern));
if (debug)
fprintf(stderr, "idutils: %s\n", strbuf_value(ib));
if (!(ip = popen(strbuf_value(ib), "r")))
die("cannot execute '%s'.", strbuf_value(ib));
cv = convert_open(type, format, root, cwd, dbpath, stdout, NOTAGS);
cv->tag_for_display = encoded_pattern;
count = 0;
strcpy(path, "./");
while ((grep = strbuf_fgets(ib, ip, STRBUF_NOCRLF)) != NULL) {
q = path + 2;
/* extract path name */
if (*grep == '/')
die("The path in the output of lid is assumed relative.\n'%s'", grep);
p = grep;
while (*p && *p != ':')
*q++ = *p++;
*q = '\0';
if ((xflag || tflag) && !*p)
die("invalid lid(idutils) output format(1). '%s'", grep);
p++;
if (Sflag) {
if (!locatestring(path, localprefix, MATCH_AT_FIRST))
continue;
}
count++;
switch (format) {
case FORMAT_PATH:
convert_put_path(cv, NULL, path);
break;
default:
/* extract line number */
while (*p && isspace(*p))
p++;
linenum = 0;
for (linenum = 0; *p && isdigit(*p); linenum = linenum * 10 + (*p++ - '0'))
;
if (*p != ':')
die("invalid lid(idutils) output format(2). '%s'", grep);
if (linenum <= 0)
die("invalid lid(idutils) output format(3). '%s'", grep);
p++;
/*
* print out.
*/
convert_put_using(cv, pattern, path, linenum, p, NULL);
break;
}
}
if (pclose(ip) != 0)
die("terminated abnormally (errno = %d).", errno);
convert_close(cv);
strbuf_close(ib);
if (vflag) {
print_count(count);
fprintf(stderr, " (using idutils index in '%s').\n", dbpath);
}
}
