/*
* Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006,
* 2007, 2008, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017,
* 2020
* Tama Communications Corporation
*
* This file is part of GNU GLOBAL.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifdef HAVE_CONFIG_H
#include
#endif
#include
#include
#include
#include
#include
#ifdef STDC_HEADERS
#include
#endif
#ifdef HAVE_STRING_H
#include
#else
#include
#endif
#ifdef HAVE_UNISTD_H
#include
#endif
#if defined(_WIN32) && !defined(__CYGWIN__)
#define WIN32_LEAN_AND_MEAN
#include
#undef SLIST_ENTRY
#endif
#include "getopt.h"
#include "global.h"
#include "parser.h"
#include "regex.h"
#include "const.h"
#include "output.h"
#include "literal.h"
#include "convert.h"
/*
* ensure GTAGSLIBPATH compares correctly
*/
#if defined(_WIN32) || defined(__DJGPP__)
#define STRCMP stricmp
#define back2slash(sb) do { \
char *p = strbuf_value(sb); \
for (; *p; p++) \
if (*p == '\\') \
*p = '/'; \
} while (0)
#else
#define STRCMP strcmp
#define back2slash(sb)
#endif
/*
* enable [set] globbing, if available
*/
#ifdef __CRT_GLOB_BRACKET_GROUPS__
int _CRT_glob = __CRT_GLOB_USE_MINGW__ | __CRT_GLOB_BRACKET_GROUPS__;
#endif
/**
* global - print locations of the specified object.
*/
static void usage(void);
static void help(void);
static void setcom(int);
int decide_tag_by_context(const char *, const char *, int);
int main(int, char **);
int completion_tags(const char *, const char *, const char *, int);
void completion(const char *, const char *, const char *, int);
void completion_idutils(const char *, const char *, const char *);
void completion_path(const char *, const char *);
void idutils(const char *, const char *);
void grep(const char *, char *const *, const char *);
void pathlist(const char *, const char *);
void parsefile(char *const *, const char *, const char *, const char *, int);
int search(const char *, const char *, const char *, const char *, int);
void tagsearch(const char *, const char *, const char *, const char *, int);
void encode(char *, int, const char *);
const char *localprefix; /**< local prefix */
int aflag; /* [option] */
int cflag; /* command */
int dflag; /* command */
int fflag; /* command */
int gflag; /* command */
int Gflag; /* [option] */
int iflag; /* [option] */
int Iflag; /* command */
int Lflag; /* [option] */
int Mflag; /* [option] */
int Nflag; /* [option] */
int nflag; /* [option] */
int oflag; /* [option] */
int Oflag; /* [option] */
int pflag; /* command */
int Pflag; /* command */
int qflag; /* [option] */
int rflag; /* [option] */
int sflag; /* [option] */
int Sflag; /* [option] */
int tflag; /* [option] */
int Tflag; /* [option] */
int uflag; /* command */
int vflag; /* [option] */
int Vflag; /* [option] */
int xflag; /* [option] */
int show_version;
int show_help;
int nofilter;
int nosource; /**< undocumented command */
int debug;
int literal; /**< 1: literal search */
int print0; /**< --print0 option */
int format;
int type; /**< path conversion type */
int match_part; /**< match part only */
int abslib; /**< absolute path only in library project */
int use_color; /**< coloring */
int limit; /**< limit of completion lines */
const char *cwd; /**< current directory */
const char *root; /**< root of source tree */
const char *dbpath; /**< dbpath directory */
const char *nearbase; /**< nearbase directory */
char *context_file;
char *context_lineno;
char *file_list;
char *scope;
char *encode_chars;
char *single_update;
char *path_style;
char *print_target;
int newline = '\n';
/*
* Path filter
*/
int do_path;
int convert_type = PATH_RELATIVE;
static void
usage(void)
{
if (!qflag)
fputs(usage_const, stderr);
exit(2);
}
static void
help(void)
{
fputs(usage_const, stdout);
fputs(help_const, stdout);
exit(0);
}
#define OPT_RESULT 128
#define OPT_FROM_HERE 129
#define OPT_ENCODE_PATH 130
#define OPT_MATCH_PART 131
#define OPT_SINGLE_UPDATE 132
#define OPT_PATH_STYLE 133
#define OPT_PATH_CONVERT 134
#define OPT_USE_COLOR 135
#define OPT_PRINT 136
#define SORT_FILTER 1
#define PATH_FILTER 2
#define BOTH_FILTER (SORT_FILTER|PATH_FILTER)
#define MATCH_PART_FIRST 1
#define MATCH_PART_LAST 2
#define MATCH_PART_ALL 3
const char *short_options = "acC:de:EifFgGIlL:MnNoOpPqrsS:tTuvVx";
struct option const long_options[] = {
{"absolute", no_argument, NULL, 'a'},
{"directory", required_argument, NULL, 'C'},
{"completion", optional_argument, NULL, 'c'},
{"definition", no_argument, NULL, 'd'},
{"extended-regexp", no_argument, NULL, 'E'},
{"regexp", required_argument, NULL, 'e'},
{"file", no_argument, NULL, 'f'},
{"first-match", no_argument, NULL, 'F'},
{"local", no_argument, NULL, 'l'},
{"file-list", required_argument, NULL, 'L'},
{"match-case", no_argument, NULL, 'M'},
{"nofilter", optional_argument, NULL, 'n'},
{"nearness", optional_argument, NULL, 'N'},
{"grep", no_argument, NULL, 'g'},
{"basic-regexp", no_argument, NULL, 'G'},
{"ignore-case", no_argument, NULL, 'i'},
{"idutils", no_argument, NULL, 'I'},
{"other", no_argument, NULL, 'o'},
{"only-other", no_argument, NULL, 'O'},
{"print-dbpath", no_argument, NULL, 'p'},
{"path", no_argument, NULL, 'P'},
{"quiet", no_argument, NULL, 'q'},
{"reference", no_argument, NULL, 'r'},
{"rootdir", no_argument, NULL, 'r'},
{"symbol", no_argument, NULL, 's'},
{"scope", required_argument, NULL, 'S'},
{"tags", no_argument, NULL, 't'},
{"through", no_argument, NULL, 'T'},
{"update", no_argument, NULL, 'u'},
{"verbose", no_argument, NULL, 'v'},
{"invert-match", optional_argument, NULL, 'V'},
{"cxref", no_argument, NULL, 'x'},
/* long name only */
{"color", optional_argument, NULL, OPT_USE_COLOR},
{"encode-path", required_argument, NULL, OPT_ENCODE_PATH},
{"from-here", required_argument, NULL, OPT_FROM_HERE},
{"debug", no_argument, &debug, 1},
{"gtagsconf", required_argument, NULL, OPT_GTAGSCONF},
{"gtagslabel", required_argument, NULL, OPT_GTAGSLABEL},
{"literal", no_argument, &literal, 1},
{"match-part", required_argument, NULL, OPT_MATCH_PART},
{"path-style", required_argument, NULL, OPT_PATH_STYLE},
{"path-convert", required_argument, NULL, OPT_PATH_CONVERT},
{"print", required_argument, NULL, OPT_PRINT},
{"print0", no_argument, &print0, 1},
{"version", no_argument, &show_version, 1},
{"help", no_argument, &show_help, 1},
{"result", required_argument, NULL, OPT_RESULT},
{"nosource", no_argument, &nosource, 1},
{"single-update", required_argument, NULL, OPT_SINGLE_UPDATE},
{ 0 }
};
static int command;
static void
setcom(int c)
{
if (command == 0)
command = c;
else if (c == 'c' && (command == 'I' || command == 'P'))
command = c;
else if (command == 'c' && (c == 'I' || c == 'P'))
;
else if (command != c)
usage();
}
/**
* decide_tag_by_context: decide tag type by context
*
* @param[in] tag tag name
* @param[in] file context file
* @param[in] lineno context lineno
* @return GTAGS, GRTAGS, GSYMS
*/
int
decide_tag_by_context(const char *tag, const char *file, int lineno)
{
#define NEXT_NUMBER(p) do { \
for (n = 0; isdigit(*p); p++) \
n = n * 10 + (*p - '0'); \
} while (0)
STRBUF *sb = NULL;
char path[MAXPATHLEN], s_fid[MAXFIDLEN];
const char *p;
GTOP *gtop;
GTP *gtp;
int db = GSYMS;
int flags = GTOP_NOREGEX;
if (iflag)
flags |= GTOP_IGNORECASE;
if (normalize(file, get_root_with_slash(), cwd, path, sizeof(path)) == NULL)
die("'%s' is out of the source project.", file);
/*
* get file id
*/
if (gpath_open(dbpath, 0) < 0)
die("GPATH not found.");
if ((p = gpath_path2fid(path, NULL)) == NULL)
die("path name in the context is not found.");
strlimcpy(s_fid, p, sizeof(s_fid));
gpath_close();
/*
* Algorithm:
*
* (1) If context is a definition of then use GRTAGS
* (2) else if there is at least one definition of then use GTAGS
* (3) else use GSYMS.
*/
gtop = gtags_open(dbpath, root, GTAGS, GTAGS_READ, 0);
gtp = gtags_first(gtop, tag, flags);
if (gtp) {
db = GTAGS;
for (; gtp; gtp = gtags_next(gtop)) {
/*
* Examine whether each definition record includes the context.
*/
p = locatestring(gtp->tagline, s_fid, MATCH_AT_FIRST);
if (p != NULL && *p == ' ') {
for (p++; *p && *p != ' '; p++)
;
if (*p++ != ' ' || !isdigit(*p))
die("Impossible! decide_tag_by_context(1)");
/*
* Standard format n $
* Compact format d,d,d,d$
*/
if (!(gtop->format & GTAGS_COMPACT)) { /* Standard format */
if (atoi(p) == lineno) {
db = GRTAGS;
goto finish;
}
} else { /* Compact format */
int n, cur, last = 0;
do {
if (!isdigit(*p))
die("Impossible! decide_tag_by_context(2)");
NEXT_NUMBER(p);
cur = last + n;
if (cur == lineno) {
db = GRTAGS;
goto finish;
}
last = cur;
if (*p == '-') {
if (!isdigit(*++p))
die("Impossible! decide_tag_by_context(3)");
NEXT_NUMBER(p);
cur = last + n;
if (lineno >= last && lineno <= cur) {
db = GRTAGS;
goto finish;
}
last = cur;
}
if (*p) {
if (*p == ',')
p++;
else
die("Impossible! decide_tag_by_context(4)");
}
} while (*p);
}
}
}
}
finish:
gtags_close(gtop);
if (db == GSYMS && getenv("GTAGSLIBPATH")) {
char libdbpath[MAXPATHLEN];
char *libdir = NULL, *nextp = NULL;
sb = strbuf_open(0);
strbuf_puts(sb, getenv("GTAGSLIBPATH"));
back2slash(sb);
for (libdir = strbuf_value(sb); db != GTAGS && 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;
gtop = gtags_open(libdbpath, root, GTAGS, GTAGS_READ, 0);
if ((gtp = gtags_first(gtop, tag, flags)) != NULL)
db = GTAGS;
gtags_close(gtop);
}
strbuf_close(sb);
}
return db;
}
int
main(int argc, char **argv)
{
const char *av = NULL;
int db;
int optchar;
int option_index = 0;
int status = 0;
/*
* pick up --gtagsconf, --gtagslabel and --directory (-C).
*/
if (preparse_options(argc, argv) < 0)
usage();
/*
* 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();
}
/*
* Open configuration file.
*/
openconf(root);
setenv_from_config();
logging_arguments(argc, argv);
while ((optchar = getopt_long(argc, argv, short_options, long_options, &option_index)) != EOF) {
switch (optchar) {
case 0:
break;
case 'a':
aflag++;
break;
case 'c':
cflag++;
setcom(optchar);
if (optarg)
limit = atoi(optarg);
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 'N':
Nflag++;
if (optarg)
nearbase = optarg;
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, "%s", usage);
*p++ = '\0';
if (!*p)
die_with_code(2, "%s", usage);
context_file = p;
}
break;
case OPT_GTAGSCONF:
case OPT_GTAGSLABEL:
case 'C':
/* 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_PRINT:
print_target = optarg;
break;
case OPT_RESULT:
if (!strcmp(optarg, "ctags-x"))
format = FORMAT_CTAGS_X;
else if (!strcmp(optarg, "ctags-xid")) /* undocumented */
format = FORMAT_CTAGS_XID;
else if (!strcmp(optarg, "ctags"))
format = FORMAT_CTAGS;
else if (!strcmp(optarg, "ctags-mod")) /* undocumented */
format = FORMAT_CTAGS_MOD;
else if (!strcmp(optarg, "ctags-plus")) /* undocumented */
format = FORMAT_CTAGS_PLUS;
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, "%s", gtags_dbpath_error);
if (print_target) {
const char *target = NULL;
if (!strcmp("dbpath", print_target))
target = dbpath;
else if (!strcmp("root", print_target))
target = root;
else if (!strcmp("conf", print_target))
target = getconfigpath();
if (target != NULL)
fprintf(stdout, "%s\n", target);
exit(0);
}
if (Nflag) {
if (!nearbase)
nearbase = get_cwd();
/*
* Nearbase is saved with regular form. You can get it
* by get_nearbase_path() later.
*/
if (set_nearbase_path(nearbase) == NULL)
die("invalid nearness file or directory (--nearness=%s).", nearbase);
}
/*
* 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) {
newline = '\0';
set_print0();
}
if (cflag && match_part == 0)
match_part = MATCH_PART_ALL;
if (cflag && context_file)
context_file = NULL;
/*
* 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 && av) {
if (!literal && 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.");
}
{
int conv_flags = 0;
if (use_color)
conv_flags |= CONVERT_COLOR;
if (gflag)
conv_flags |= CONVERT_GREP;
if (Gflag)
conv_flags |= CONVERT_BASIC;
if (iflag)
conv_flags |= CONVERT_ICASE;
if (Iflag)
conv_flags |= CONVERT_IDUTILS;
if (Pflag)
conv_flags |= CONVERT_PATH;
set_convert_flags(conv_flags);
}
/*
* 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;
}
/**
* completion_tags: print completion list of specified prefix
*
* @param[in] dbpath dbpath directory
* @param[in] root root directory
* @param[in] prefix prefix of primary key
* @param[in] db GTAGS,GRTAGS,GSYMS
* @return number of words
*/
int
completion_tags(const char *dbpath, const char *root, const char *prefix, int db)
{
int flags = GTOP_KEY | GTOP_NOREGEX | GTOP_PREFIX;
GTOP *gtop = gtags_open(dbpath, root, db, GTAGS_READ, 0);
GTP *gtp;
int count = 0;
if (iflag)
flags |= GTOP_IGNORECASE;
for (gtp = gtags_first(gtop, prefix, flags); gtp; gtp = gtags_next(gtop)) {
if (limit && count >= limit)
break;
fputs(gtp->tag, stdout);
fputc(newline, stdout);
count++;
}
if (debug)
gtags_show_statistics(gtop);
gtags_close(gtop);
return count;
}
/**
* completion: print completion list of specified prefix
*
* @param[in] dbpath dbpath directory
* @param[in] root root directory
* @param[in] prefix prefix of primary key
* @param[in] db GTAGS,GRTAGS,GSYMS
*/
void
completion(const char *dbpath, const char *root, const char *prefix, int db)
{
int count, total = 0;
char libdbpath[MAXPATHLEN];
if (prefix && *prefix == 0) /* In the case global -c '' */
prefix = NULL;
count = completion_tags(dbpath, root, prefix, db);
/*
* search in library path.
*/
if (db == GTAGS && getenv("GTAGSLIBPATH") && (count == 0 || Tflag) && !Sflag) {
STRBUF *sb = strbuf_open(0);
char *libdir, *nextp = NULL;
strbuf_puts(sb, getenv("GTAGSLIBPATH"));
back2slash(sb);
/*
* 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 = completion_tags(libdbpath, libdir, prefix, db);
total += count;
if (count > 0 && !Tflag)
break;
if (total >= limit)
break;
}
strbuf_close(sb);
}
/* return total; */
}
/**
* completion_idutils: print completion list of specified prefix
*
* @param[in] dbpath dbpath directory
* @param[in] root root directory
* @param[in] prefix prefix of primary key
*/
void
completion_idutils(const char *dbpath, const char *root, const char *prefix)
{
FILE *ip;
STRBUF *sb = strbuf_open(0);
char *lid = usable("lid");
char *line, *p;
char *argv[10];
int count = 0;
int i = 0;
if (prefix && *prefix == 0) /* In the case global -c '' */
prefix = NULL;
/*
* make lid command line.
* Invoke lid with the --result=grep option to generate grep format.
*
* When lid(1) not found in the PATH, use LID macro if it exists.
* This is needed because lid is called indirectly from CGI scripts.
* In the CGI scripts, PATH is limited to '/bin:/usr/bin:/usr/local/bin'.
*/
if (!lid) {
if (strcmp(LID, "no") != 0 && test("fx", LID))
lid = LID;
else
die("lid(idutils) not found.");
}
if (chdir(root) < 0)
die("cannot move to '%s' directory.", root);
#if (defined(_WIN32) && !defined(__CYGWIN__)) || defined(__DJGPP__)
strbuf_puts(sb, lid);
strbuf_sprintf(sb, " --file=%s/ID", quote_shell(dbpath));
strbuf_puts(sb, " --key=token");
if (iflag)
strbuf_puts(sb, " --ignore-case");
if (prefix) {
strbuf_putc(sb, ' ');
strbuf_putc(sb, '"');
strbuf_putc(sb, '^');
strbuf_puts(sb, prefix);
strbuf_putc(sb, '"');
}
if (debug)
fprintf(stderr, "completion_idutils: %s\n", strbuf_value(sb));
if (!(ip = popen(strbuf_value(sb), "r")))
die("cannot execute '%s'.", strbuf_value(sb));
#else
/*
* This function is called from the CGI scripts of htags(1).
* In order not to cause unnecessary anxiety, popen(3) is not used in Unix.
*/
strbuf_puts0(sb, makepath(dbpath, "ID", NULL));
if (prefix) {
strbuf_putc(sb, '^');
strbuf_puts0(sb, prefix);
}
p = strbuf_value(sb);
argv[i++] = lid;
argv[i++] = "--file";
argv[i++] = p; /* dbpath/ID */
argv[i++] = "--key=token";
if (iflag)
argv[i++] = "--ignore-case";
if (prefix)
argv[i++] = next_string(p); /* ^prefix */
argv[i] = NULL;
if (debug) {
fprintf(stderr, "completion_idutils: \n");
for (i = 0; argv[i] != NULL; i++)
fprintf(stderr, "argv[%d] = |%s|\n", i, argv[i]);
}
if (!(ip = secure_popen(lid, "r", argv)))
die("cannot execute '%s'.", lid);
#endif
while ((line = strbuf_fgets(sb, ip, STRBUF_NOCRLF)) != NULL) {
if (limit && count >= limit)
break;
for (p = line; *p && *p != ' '; p++)
;
if (*p == '\0') {
warning("Invalid line: %s", line);
continue;
}
*p = '\0';
fputs(line, stdout);
fputc(newline, stdout);
count++;
}
#if (defined(_WIN32) && !defined(__CYGWIN__)) || defined(__DJGPP__)
if (pclose(ip) != 0)
die("terminated abnormally (errno = %d).", errno);
#else
if (secure_pclose(ip) != 0)
die("terminated abnormally (errno = %d).", errno);
#endif
strbuf_close(sb);
}
/**
* completion_path: print candidate path list.
*
* @param[in] dbpath dbpath directory
* @param[in] prefix prefix of primary key
*/
void
completion_path(const char *dbpath, const char *prefix)
{
GFIND *gp;
const char *localprefix = "./";
DBOP *dbop = dbop_open(NULL, 1, 0600, DBOP_RAW);
const char *path;
int prefix_length;
int target = GPATH_SOURCE;
int flags = (match_part == MATCH_PART_LAST) ? MATCH_LAST : MATCH_FIRST;
int count = 0;
if (dbop == NULL)
die("cannot open temporary file.");
if (prefix && *prefix == 0) /* In the case global -c '' */
prefix = NULL;
prefix_length = (prefix == NULL) ? 0 : strlen(prefix);
if (oflag)
target = GPATH_BOTH;
if (Oflag)
target = GPATH_OTHER;
if (iflag || getconfb("icase_path"))
flags |= IGNORE_CASE;
#if _WIN32 || __DJGPP__
else if (!Mflag)
flags |= IGNORE_CASE;
#endif
gp = gfind_open(dbpath, localprefix, target, 0);
while ((path = gfind_read(gp)) != NULL) {
path++; /* skip '.'*/
if (prefix == NULL) {
dbop_put(dbop, path + 1, "");
} else if (match_part == MATCH_PART_ALL) {
const char *p = path;
while ((p = locatestring(p, prefix, flags)) != NULL) {
dbop_put(dbop, p, "");
p += prefix_length;
}
} else {
const char *p = locatestring(path, prefix, flags);
if (p != NULL) {
dbop_put(dbop, p, "");
}
}
}
gfind_close(gp);
for (path = dbop_first(dbop, NULL, NULL, DBOP_KEY); path != NULL; path = dbop_next(dbop)) {
if (limit && count >= limit)
break;
fputs(path, stdout);
fputc(newline, stdout);
count++;
}
dbop_close(dbop);
}
/*
* Output filter
*
* (1) Old architecture (- GLOBAL-4.7.8)
*
* process1 process2 process3
* +=============+ +===========+ +===========+
* |global(write)|->|sort filter|->|path filter|->[stdout]
* +=============+ +===========+ +===========+
*
* (2) Recent architecture (GLOBAL-5.0 - 5.3)
*
* 1 process
* +===========================================+
* |global(write)->[sort filter]->[path filter]|->[stdout]
* +===========================================+
*
* (3) Current architecture (GLOBAL-5.4 -)
*
* 1 process
* +===========================================+
* |[sort filter]->global(write)->[path filter]|->[stdout]
* +===========================================+
*
* Sort filter is implemented in gtagsop module (libutil/gtagsop.c).
* Path filter is implemented in convert module (libutil/convert.c).
*/
/**
* print number of object.
*
* This procedure is commonly used except for the -P option.
*/
void
print_count(int number)
{
const char *target = format == FORMAT_PATH ? "file" : "object";
switch (number) {
case 0:
fprintf(stderr, "object not found");
break;
case 1:
fprintf(stderr, "1 %s located", target);
break;
default:
fprintf(stderr, "%d %ss located", number, target);
break;
}
}
/**
* idutils: lid(idutils) pattern
*
* @param[in] pattern POSIX regular expression
* @param[in] dbpath "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];
char *lid = usable("lid");
int linenum, count;
char *p, *q, *grep;
char *argv[20];
int i = 0;
/*
* When lid(1) not found in the PATH, use LID macro if it exists.
* This is needed because lid is called indirectly from CGI scripts.
* In the CGI scripts, PATH is limited to '/bin:/usr/bin:/usr/local/bin'.
*/
if (!lid) {
if (strcmp(LID, "no") != 0 && test("fx", LID))
lid = LID;
else
die("lid(idutils) not found.");
}
if (!test("f", makepath(dbpath, "ID", NULL)))
die("ID file not found.");
/*
* PWD is needed for lid.
*/
set_env("PWD", root);
/*
* 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 (defined(_WIN32) && !defined(__CYGWIN__)) || defined(__DJGPP__)
strbuf_puts(ib, lid);
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 (literal)
strbuf_puts(ib, " --literal");
else 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));
#else
/*
* This function is called from the CGI scripts of htags(1).
* In order not to cause unnecessary anxiety, popen(3) is not used in Unix.
*/
strbuf_puts0(ib, makepath(dbpath, "ID", NULL));
strbuf_puts0(ib, pattern);
p = strbuf_value(ib);
argv[i++] = lid;
argv[i++] = "--file";
argv[i++] = p; /* dbpath/ID */
argv[i++] = "--separator=newline";
if (format == FORMAT_PATH) {
argv[i++] = "--result=filenames";
argv[i++] = "--key=none";
} else {
argv[i++] = "--result=grep";
}
if (iflag)
argv[i++] = "--ignore-case";
if (literal)
argv[i++] = "--literal";
else if (isregex(pattern))
argv[i++] = "--regexp";
argv[i++] = next_string(p); /* pattern */
argv[i] = NULL;
if (debug) {
fprintf(stderr, "idutils: \n");
for (i = 0; argv[i] != NULL; i++)
fprintf(stderr, "argv[%d] = |%s|\n", i, argv[i]);
}
if (!(ip = secure_popen(lid, "r", argv)))
die("cannot execute '%s'.", strbuf_value(ib));
#endif
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 (defined(_WIN32) && !defined(__CYGWIN__)) || defined(__DJGPP__)
if (pclose(ip) != 0)
die("terminated abnormally (errno = %d).", errno);
#else
if (secure_pclose(ip) != 0)
die("terminated abnormally (errno = %d).", errno);
#endif
convert_close(cv);
strbuf_close(ib);
if (vflag) {
print_count(count);
fprintf(stderr, " (using idutils index in '%s').\n", dbpath);
}
}
/**
* grep: grep pattern
*
* @param[in] pattern POSIX regular expression
* @param argv
* @param dbpath
*/
void
grep(const char *pattern, char *const *argv, const char *dbpath)
{
FILE *fp;
CONVERT *cv;
GFIND *gp = NULL;
STRBUF *ib = strbuf_open(MAXBUFLEN);
const char *path;
char encoded_pattern[IDENTLEN];
const char *buffer;
int linenum, count;
int flags = 0;
int target = GPATH_SOURCE;
regex_t preg;
int user_specified = 1;
int gfind_flags = 0;
/*
* convert spaces into %FF format.
*/
encode(encoded_pattern, sizeof(encoded_pattern), pattern);
/*
* literal search available?
*/
if (!literal) {
const char *p = pattern;
int normal = 1;
for (; *p; p++) {
if (!(isalpha(*p) || isdigit(*p) || isblank(*p) || *p == '_')) {
normal = 0;
break;
}
}
if (normal)
literal = 1;
}
if (oflag)
target = GPATH_BOTH;
if (Oflag)
target = GPATH_OTHER;
if (Nflag)
gfind_flags |= GPATH_NEARSORT;
if (literal) {
literal_comple(pattern);
} else {
if (!Gflag)
flags |= REG_EXTENDED;
if (iflag)
flags |= REG_ICASE;
if (regcomp(&preg, pattern, flags) != 0)
die("invalid regular expression.");
}
cv = convert_open(type, format, root, cwd, dbpath, stdout, NOTAGS);
cv->tag_for_display = encoded_pattern;
count = 0;
if (*argv && file_list)
args_open_both(argv, file_list);
else if (*argv)
args_open(argv);
else if (file_list)
args_open_filelist(file_list);
else {
args_open_gfind(gp = gfind_open(dbpath, localprefix, target, gfind_flags));
user_specified = 0;
}
while ((path = args_read()) != NULL) {
if (user_specified) {
static char buf[MAXPATHLEN];
if (normalize(path, get_root_with_slash(), cwd, buf, sizeof(buf)) == NULL) {
warning("'%s' is out of the source project.", path);
continue;
}
if (test("d", buf)) {
warning("'%s' is a directory. Ignored.", path);
continue;
}
if (!test("f", buf)) {
warning("'%s' not found. Ignored.", path);
continue;
}
path = buf;
}
if (Sflag && !locatestring(path, localprefix, MATCH_AT_FIRST))
continue;
if (literal) {
int n = literal_search(cv, path);
if (n > 0)
count += n;
} else {
if (!(fp = fopen(path, "r")))
die("cannot open file '%s'.", path);
linenum = 0;
while ((buffer = strbuf_fgets(ib, fp, STRBUF_NOCRLF)) != NULL) {
int result = regexec(&preg, buffer, 0, 0, 0);
linenum++;
if ((!Vflag && result == 0) || (Vflag && result != 0)) {
count++;
if (format == FORMAT_PATH) {
convert_put_path(cv, NULL, path);
break;
} else {
convert_put_using(cv, pattern, path, linenum, buffer,
(user_specified) ? NULL : gp->dbop->lastdat);
}
}
}
fclose(fp);
}
}
args_close();
convert_close(cv);
strbuf_close(ib);
if (literal == 0)
regfree(&preg);
if (vflag) {
print_count(count);
fprintf(stderr, " (no index used).\n");
}
}
/**
* pathlist: print candidate path list.
*
* @param[in] pattern
* @param[in] dbpath
*/
void
pathlist(const char *pattern, const char *dbpath)
{
GFIND *gp;
CONVERT *cv;
const char *path, *p;
regex_t preg;
int count;
int target = GPATH_SOURCE;
int gfind_flags = 0;
if (oflag)
target = GPATH_BOTH;
if (Oflag)
target = GPATH_OTHER;
if (Nflag)
gfind_flags |= GPATH_NEARSORT;
if (pattern) {
int flags = 0;
char edit[IDENTLEN];
if (!Gflag)
flags |= REG_EXTENDED;
if (iflag || getconfb("icase_path"))
flags |= REG_ICASE;
#if _WIN32 || __DJGPP__
else if (!Mflag)
flags |= REG_ICASE;
#endif /* _WIN32 */
/*
* We assume '^aaa' as '^/aaa'.
*/
if (literal) {
strlimcpy(edit, quote_string(pattern), sizeof(edit));
pattern = edit;
} else if (*pattern == '^' && *(pattern + 1) != '/') {
snprintf(edit, sizeof(edit), "^/%s", pattern + 1);
pattern = edit;
}
if (regcomp(&preg, pattern, flags) != 0)
die("invalid regular expression.");
}
if (!localprefix)
localprefix = "./";
cv = convert_open(type, format, root, cwd, dbpath, stdout, GPATH);
cv->tag_for_display = "path";
count = 0;
gp = gfind_open(dbpath, localprefix, target, gfind_flags);
while ((path = gfind_read(gp)) != NULL) {
/*
* skip localprefix because end-user doesn't see it.
*/
p = path + strlen(localprefix) - 1;
if (pattern) {
int result = regexec(&preg, p, 0, 0, 0);
if ((!Vflag && result != 0) || (Vflag && result == 0))
continue;
} else if (Vflag)
continue;
if (format == FORMAT_PATH)
convert_put_path(cv, pattern, path);
else
convert_put_using(cv, pattern, path, 1, " ", gp->dbop->lastdat);
count++;
}
gfind_close(gp);
convert_close(cv);
if (pattern)
regfree(&preg);
if (vflag) {
switch (count) {
case 0:
fprintf(stderr, "file not found");
break;
case 1:
fprintf(stderr, "1 file located");
break;
default:
fprintf(stderr, "%d files located", count);
break;
}
fprintf(stderr, " (using '%s').\n", makepath(dbpath, dbname(GPATH), NULL));
}
}
/**
* void parsefile(char *const *argv, const char *cwd, const char *root, const char *dbpath, int db)
*
* parsefile: parse file to pick up tags.
*
* @param[in] argv
* @param[in] cwd current directory
* @param[in] root root directory of source tree
* @param[in] dbpath dbpath
* @param[in] db type of parse
*/
#define TARGET_DEF (1 << GTAGS)
#define TARGET_REF (1 << GRTAGS)
#define TARGET_SYM (1 << GSYMS)
struct parsefile_data {
CONVERT *cv;
DBOP *dbop;
int target;
int extractmethod;
int count;
const char *fid; /**< fid of the file under processing */
};
static void
put_syms(int type, const char *tag, int lno, const char *path, const char *line_image, void *arg)
{
struct parsefile_data *data = arg;
const char *key;
if (format == FORMAT_PATH && data->count > 0)
return;
switch (type) {
case PARSER_DEF:
if (!(data->target & TARGET_DEF))
return;
break;
case PARSER_REF_SYM:
if (!(data->target & (TARGET_REF | TARGET_SYM)))
return;
/*
* extract method when class method definition.
*
* Ex: Class::method(...)
*
* key = 'method'
* data = 'Class::method 103 ./class.cpp ...'
*/
if (data->extractmethod) {
if ((key = locatestring(tag, ".", MATCH_LAST)) != NULL)
key++;
else if ((key = locatestring(tag, "::", MATCH_LAST)) != NULL)
key += 2;
else
key = tag;
} else {
key = tag;
}
if (data->target == TARGET_REF || data->target == TARGET_SYM) {
if (dbop_get(data->dbop, key) != NULL) {
if (!(data->target & TARGET_REF))
return;
} else {
if (!(data->target & TARGET_SYM))
return;
}
}
break;
default:
return;
}
convert_put_using(data->cv, tag, path, lno, line_image, data->fid);
data->count++;
}
void
parsefile(char *const *argv, const char *cwd, const char *root, const char *dbpath, int db)
{
int count = 0;
int flags = 0;
STRBUF *sb = strbuf_open(0);
char *langmap;
const char *plugin_parser, *av;
char path[MAXPATHLEN];
struct parsefile_data data;
flags = 0;
if (vflag)
flags |= PARSER_VERBOSE;
if (debug)
flags |= PARSER_DEBUG;
/*
if (wflag)
flags |= PARSER_WARNING;
*/
if (getenv("GTAGSFORCEENDBLOCK"))
flags |= PARSER_END_BLOCK;
if (db == GRTAGS + GSYMS)
data.target = TARGET_REF|TARGET_SYM;
else
data.target = 1 << db;
data.extractmethod = getconfb("extractmethod");
if (getconfs("langmap", sb))
langmap = check_strdup(strbuf_value(sb));
else
langmap = NULL;
strbuf_reset(sb);
if (getconfs("gtags_parser", sb))
plugin_parser = strbuf_value(sb);
else
plugin_parser = NULL;
data.cv = convert_open(type, format, root, cwd, dbpath, stdout, db);
if (gpath_open(dbpath, 0) < 0)
die("GPATH not found.");
if (data.target == TARGET_REF || data.target == TARGET_SYM) {
data.dbop = dbop_open(makepath(dbpath, dbname(GTAGS), NULL), 0, 0, 0);
if (data.dbop == NULL)
die("%s not found.", dbname(GTAGS));
} else {
data.dbop = NULL;
}
data.fid = NULL;
parser_init(langmap, plugin_parser);
if (langmap != NULL)
free(langmap);
if (*argv && file_list)
args_open_both(argv, file_list);
else if (*argv)
args_open(argv);
else if (file_list)
args_open_filelist(file_list);
else
args_open_nop();
while ((av = args_read()) != NULL) {
/*
* convert the path into relative to the root directory of source tree.
*/
if (normalize(av, get_root_with_slash(), cwd, path, sizeof(path)) == NULL) {
if (!qflag)
die("'%s' is out of the source project.", av);
continue;
}
if (!test("f", makepath(root, path, NULL))) {
if (!qflag) {
if (test("d", NULL))
die("'%s' is not a source file.", av);
else
die("'%s' not found.", av);
}
continue;
}
/*
* Memorize the file id of the path. This is used in put_syms().
*/
{
static char s_fid[MAXFIDLEN];
int type = 0;
const char *p = gpath_path2fid(path, &type);
if (!p || type != GPATH_SOURCE) {
if (!qflag)
die("'%s' is not a source file.", av);
continue;
}
strlimcpy(s_fid, p, sizeof(s_fid));
data.fid = s_fid;
}
if (Sflag && !locatestring(path, localprefix, MATCH_AT_FIRST))
continue;
data.count = 0;
parse_file(path, flags, put_syms, &data);
count += data.count;
}
args_close();
parser_exit();
/*
* Settlement
*/
if (data.dbop != NULL)
dbop_close(data.dbop);
gpath_close();
convert_close(data.cv);
strbuf_close(sb);
if (vflag) {
print_count(count);
fprintf(stderr, " (no index used).\n");
}
}
/**
* search: search specified function
*
* @param[in] pattern search pattern
* @param[in] root root of source tree
* @param[in] cwd current directory
* @param[in] dbpath database directory
* @param[in] db GTAGS,GRTAGS,GSYMS
* @return count of output lines
*/
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;
start_output(format, nosource);
/*
* open tag file.
*/
gtop = gtags_open(dbpath, root, db, GTAGS_READ, debug ? GTAGS_DEBUG : 0);
cv = convert_open(type, format, root, cwd, dbpath, stdout, db);
/*
* search through tag file.
*/
if (nofilter & SORT_FILTER)
flags |= GTOP_NOSORT;
else if (Nflag)
flags |= GTOP_NEARSORT;
if (literal)
flags |= GTOP_NOREGEX;
else if (Gflag)
flags |= GTOP_BASICREGEX;
if (format == FORMAT_PATH)
flags |= GTOP_PATH;
if (iflag)
flags |= GTOP_IGNORECASE;
for (gtp = gtags_first(gtop, pattern, flags); gtp; gtp = gtags_next(gtop)) {
if (Sflag && !locatestring(gtp->path, localprefix, MATCH_AT_FIRST))
continue;
count += output_with_formatting(cv, gtp, root, gtop->format);
}
convert_close(cv);
if (debug)
gtags_show_statistics(gtop);
gtags_close(gtop);
end_output();
return count;
}
/**
* 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 (^$ => )
*/
if (!literal && 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"));
back2slash(sb);
/*
* 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);
}
}
/*
* encode: string copy with converting blank chars into %ff format.
*
* @param[out] to result
* @param[in] size size of to buffer
* @param[in] from string
*/
void
encode(char *to, int size, const char *from)
{
const char *p;
char *e = to;
for (p = from; *p; p++) {
if (*p == '%' || *p == ' ' || *p == '\t') {
if (size <= 3)
break;
snprintf(e, size, "%%%02x", *p);
e += 3;
size -= 3;
} else {
if (size <= 1)
break;
*e++ = *p;
size--;
}
}
*e = 0;
}