/* * Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2008, * 2009, 2010, 2012, 2014, 2015, 2016, 2018, 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 #include #include #if TIME_WITH_SYS_TIME #include #include #else #if HAVE_SYS_TIME_H #include #else #include #endif #endif #ifdef STDC_HEADERS #include #endif #ifdef HAVE_STRING_H #include #else #include #endif #ifdef HAVE_UNISTD_H #include #endif #include "getopt.h" #include "global.h" #include "parser.h" #include "const.h" /* * enable [set] globbing, if available */ #ifdef __CRT_GLOB_BRACKET_GROUPS__ int _CRT_glob = __CRT_GLOB_USE_MINGW__ | __CRT_GLOB_BRACKET_GROUPS__; #endif /* gtags - create tag files for global. */ static void usage(void); static void help(void); int printconf(const char *); int main(int, char **); int incremental(const char *, const char *); void updatetags(const char *, const char *, IDSET *, STRBUF *); void createtags(const char *, const char *); int cflag; /**< compact format */ int iflag; /**< incremental update */ int Iflag; /**< make idutils index */ int Oflag; /**< use objdir */ int qflag; /**< quiet mode */ int wflag; /**< warning message */ int vflag; /**< verbose mode */ int show_version; int show_help; int show_config; int skip_unreadable; int skip_symlink; int accept_dotfiles; char *gtagsconf; char *gtagslabel; int debug; const char *config_name; const char *file_list; const char *dump_target; char *single_update; int statistics = STATISTICS_STYLE_NONE; int explain; #ifdef USE_SQLITE3 int use_sqlite3; #endif #define GTAGSFILES "gtags.files" int extractmethod; int total; 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); } /** * printconf: print configuration data. * * @param[in] name label of config data * @return exit code */ int printconf(const char *name) { int num; int exist = 1; if (getconfn(name, &num)) fprintf(stdout, "%d\n", num); else if (getconfb(name)) fprintf(stdout, "1\n"); else { STRBUF *sb = strbuf_open(0); if (getconfs(name, sb)) fprintf(stdout, "%s\n", strbuf_value(sb)); else exist = 0; strbuf_close(sb); } return exist; } const char *short_options = "cC:d:f:iIn:oOqvwse"; struct option const long_options[] = { /* * These options have long name and short name. * We throw them to the processing of short options. * * Though the -o(--omit-gsyms) was removed, this code * is left for compatibility. */ {"compact", no_argument, NULL, 'c'}, {"directory", required_argument, NULL, 'C'}, {"dump", required_argument, NULL, 'd'}, {"file", required_argument, NULL, 'f'}, {"idutils", no_argument, NULL, 'I'}, {"incremental", no_argument, NULL, 'i'}, {"max-args", required_argument, NULL, 'n'}, {"omit-gsyms", no_argument, NULL, 'o'}, /* removed */ {"objdir", no_argument, NULL, 'O'}, {"quiet", no_argument, NULL, 'q'}, {"verbose", no_argument, NULL, 'v'}, {"warning", no_argument, NULL, 'w'}, /* * The following are long name only. */ #define OPT_CONFIG 128 #define OPT_PATH 129 #define OPT_SINGLE_UPDATE 130 #define OPT_ACCEPT_DOTFILES 131 #define OPT_SKIP_UNREADABLE 132 #define OPT_GTAGSSKIP_SYMLINK 133 /* flag value */ {"accept-dotfiles", no_argument, NULL, OPT_ACCEPT_DOTFILES}, {"debug", no_argument, &debug, 1}, {"explain", no_argument, &explain, 1}, #ifdef USE_SQLITE3 {"sqlite3", no_argument, &use_sqlite3, 1}, #endif {"skip-unreadable", no_argument, NULL, OPT_SKIP_UNREADABLE}, {"statistics", no_argument, &statistics, STATISTICS_STYLE_TABLE}, {"version", no_argument, &show_version, 1}, {"help", no_argument, &show_help, 1}, /* accept value */ {"config", optional_argument, NULL, OPT_CONFIG}, {"gtagsconf", required_argument, NULL, OPT_GTAGSCONF}, {"gtagslabel", required_argument, NULL, OPT_GTAGSLABEL}, {"skip-symlink", optional_argument, NULL, OPT_GTAGSSKIP_SYMLINK}, {"path", required_argument, NULL, OPT_PATH}, {"single-update", required_argument, NULL, OPT_SINGLE_UPDATE}, { 0 } }; static const char *langmap = DEFAULTLANGMAP; /**< langmap */ static const char *gtags_parser; /**< gtags_parser */ /** * load configuration variables. */ static void configuration() { STRBUF *sb = strbuf_open(0); if (getconfb("extractmethod")) extractmethod = 1; strbuf_reset(sb); if (getconfs("langmap", sb)) langmap = check_strdup(strbuf_value(sb)); strbuf_reset(sb); if (getconfs("gtags_parser", sb)) gtags_parser = check_strdup(strbuf_value(sb)); strbuf_close(sb); } int main(int argc, char **argv) { char dbpath[MAXPATHLEN]; char cwd[MAXPATHLEN]; STRBUF *sb = strbuf_open(0); int optchar; int option_index = 0; STATISTICS_TIME *tim; /* * pick up --gtagsconf, --gtagslabel and --directory (-C). */ if (preparse_options(argc, argv) < 0) usage(); /* * Get the project root directory. */ if (!vgetcwd(cwd, MAXPATHLEN)) die("cannot get current directory."); canonpath(cwd); /* * Load configuration file. */ openconf(cwd); configuration(); setenv_from_config(); { char *env = getenv("GTAGS_OPTIONS"); if (env && *env) argv = prepend_options(&argc, argv, env); } /* * Execute gtags_hook before the jobs. * The hook is not executed when the following options are specified. * --help, --dump, --config, --version * These are informational options only. */ { int skip_hook = 0; /* Make a decision whether to execute gtags_hook. */ while ((optchar = getopt_long(argc, argv, short_options, long_options, &option_index)) != EOF) { switch (optchar) { case OPT_CONFIG: case 'd': skip_hook++; break; default: break; } } optind = 1; /* Reset getopt(3) library. */ if (show_version || show_help) skip_hook++; if (skip_hook) { if (debug) fprintf(stderr, "Gtags_hook is skipped.\n"); } else if (getconfs("gtags_hook", sb)) { char *p = serialize_options(argc, argv); set_env("GTAGS_COMMANDLINE", p); free(p); if (system(strbuf_value(sb))) fprintf(stderr, "gtags-hook failed: %s\n", strbuf_value(sb)); } } logging_arguments(argc, argv); while ((optchar = getopt_long(argc, argv, short_options, long_options, &option_index)) != EOF) { switch (optchar) { case 0: /* already flags set */ break; case OPT_CONFIG: show_config = 1; if (optarg) config_name = optarg; break; case OPT_GTAGSCONF: case OPT_GTAGSLABEL: case 'C': /* These options are already parsed in preparse_options(). */ break; case OPT_SINGLE_UPDATE: iflag++; single_update = optarg; break; case OPT_ACCEPT_DOTFILES: accept_dotfiles = 1; break; case OPT_SKIP_UNREADABLE: skip_unreadable = 1; break; case OPT_GTAGSSKIP_SYMLINK: skip_symlink = SKIP_SYMLINK_FOR_ALL; if (optarg) { if (!strcmp(optarg, "f")) skip_symlink = SKIP_SYMLINK_FOR_FILE; else if (!strcmp(optarg, "d")) skip_symlink = SKIP_SYMLINK_FOR_DIR; else if (!strcmp(optarg, "a")) skip_symlink = SKIP_SYMLINK_FOR_ALL; else die("--skip-symlink: %s: unknown type.", optarg); } break; case 'c': cflag++; break; case 'd': dump_target = optarg; break; case 'f': file_list = optarg; break; case 'i': iflag++; break; case 'I': Iflag++; break; case 'o': /* * Though the -o(--omit-gsyms) was removed, this code * is left for compatibility. */ break; case 'O': Oflag++; break; case 'q': qflag++; break; case 'w': wflag++; break; case 'v': vflag++; break; default: usage(); break; } } if (skip_symlink) set_skip_symlink(skip_symlink); if (qflag) { vflag = 0; setquiet(); } if (vflag) setverbose(); if (wflag) set_langmap_wflag(); if (show_version) version(NULL, vflag); if (show_help) help(); argc -= optind; argv += optind; /* If dbpath is specified, -O(--objdir) option is ignored. */ if (argc > 0) Oflag = 0; if (show_config) { openconf(setupdbpath(0) == 0 ? get_root() : NULL); if (config_name) printconf(config_name); else fprintf(stdout, "%s\n", getconfline()); exit(0); } else if (dump_target) { /* * Dump a tag file. */ DBOP *dbop = NULL; const char *dat = 0; int is_gpath = 0; if (!test("f", dump_target)) die("file '%s' not found.", dump_target); if ((dbop = dbop_open(dump_target, 0, 0, DBOP_RAW)) == NULL) die("file '%s' is not a tag file.", dump_target); /* * The file which has a NEXTKEY record is GPATH. */ if (dbop_get(dbop, NEXTKEY)) is_gpath = 1; for (dat = dbop_first(dbop, NULL, NULL, 0); dat != NULL; dat = dbop_next(dbop)) { const char *flag = is_gpath ? dbop_getflag(dbop) : ""; if (*flag) printf("%s\t%s\t%s\n", dbop->lastkey, dat, flag); else printf("%s\t%s\n", dbop->lastkey, dat); } dbop_close(dbop); exit(0); } else if (Iflag) { #define REQUIRED_MKID_VERSION "4.5" char *p; if (!usable("mkid")) die("mkid not found."); if (read_first_line("mkid --version", sb)) die("mkid cannot executed."); p = strrchr(strbuf_value(sb), ' '); if (p == NULL) die("invalid version string of mkid: %s", strbuf_value(sb)); switch (check_version(p + 1, REQUIRED_MKID_VERSION) #ifdef _WIN32 | strcmp(p + 1, "3.2.99") == 0 #endif ) { case 1: break; /* OK */ case 0: die("mkid version %s or later is required.", REQUIRED_MKID_VERSION); default: die("invalid version string of mkid: %s", strbuf_value(sb)); } } /* * If 'gtags.files' exists, use it as a file list. * If the file_list other than "-" is given, it must be readable file. */ if (file_list == NULL && test("f", GTAGSFILES)) file_list = GTAGSFILES; if (file_list && strcmp(file_list, "-")) { if (test("d", file_list)) die("'%s' is a directory.", file_list); else if (!test("f", file_list)) die("'%s' not found.", file_list); else if (!test("r", file_list)) die("'%s' is not readable.", file_list); } /* * Regularize the path name for single updating (--single-update). */ if (single_update) { static char regular_path_name[MAXPATHLEN]; char *p = single_update; #if _WIN32 || __DJGPP__ for (; *p; p++) if (*p == '\\') *p = '/'; p = single_update; #define LOCATEFLAG MATCH_AT_FIRST|IGNORE_CASE #else #define LOCATEFLAG MATCH_AT_FIRST #endif if (isabspath(p)) { char *q = locatestring(p, cwd, LOCATEFLAG); if (q && *q == '/') snprintf(regular_path_name, MAXPATHLEN, "./%s", q + 1); else die("path '%s' is out of the project.", p); } else { if (p[0] == '.' && p[1] == '/') snprintf(regular_path_name, MAXPATHLEN, "%s", p); else snprintf(regular_path_name, MAXPATHLEN, "./%s", p); } single_update = regular_path_name; } /* * Decide directory (dbpath) in which gtags make tag files. * * Gtags create tag files at current directory by default. * If dbpath is specified as an argument then use it. * If the -i option specified and both GTAGS and GRTAGS exists * at one of the candidate directories then gtags use existing * tag files. */ if (iflag) { if (argc > 0) realpath(*argv, dbpath); else if (!gtagsexist(cwd, dbpath, MAXPATHLEN, vflag)) strlimcpy(dbpath, cwd, sizeof(dbpath)); } else { if (argc > 0) realpath(*argv, dbpath); else if (Oflag) { char *objdir = getobjdir(cwd, vflag); if (objdir == NULL) die("Objdir not found."); strlimcpy(dbpath, objdir, sizeof(dbpath)); } else strlimcpy(dbpath, cwd, sizeof(dbpath)); } if (iflag && (!test("f", makepath(dbpath, dbname(GTAGS), NULL)) || !test("f", makepath(dbpath, dbname(GRTAGS), NULL)) || !test("f", makepath(dbpath, dbname(GPATH), NULL)))) { if (wflag) warning("GTAGS, GRTAGS or GPATH not found. -i option ignored."); iflag = 0; } if (!test("d", dbpath)) die("directory '%s' not found.", dbpath); /* * Start processing. */ if (accept_dotfiles) set_accept_dotfiles(); if (skip_unreadable) set_skip_unreadable(); if (vflag) { const char *config_path = getconfigpath(); const char *config_label = getconfiglabel(); fprintf(stderr, "[%s] Gtags started.\n", now()); if (config_path) fprintf(stderr, " Using configuration file '%s'.\n", config_path); else { fprintf(stderr, " Using default configuration.\n"); if (getenv("GTAGSLABEL")) fprintf(stderr, " GTAGSLABEL(--gtagslabel) ignored since configuration file not found.\n"); } if (config_label) fprintf(stderr, " Using configuration label '%s'.\n", config_label); if (file_list) fprintf(stderr, " Using '%s' as a file list.\n", file_list); } /* * initialize parser. */ if (vflag && gtags_parser) fprintf(stderr, " Using plug-in parser.\n"); parser_init(langmap, gtags_parser); /* * Start statistics. */ init_statistics(); /* * incremental update. */ if (iflag) { /* * Version check. If existing tag files are old enough * gtagsopen() abort with error message. */ GTOP *gtop = gtags_open(dbpath, cwd, GTAGS, GTAGS_MODIFY, 0); gtags_close(gtop); /* * GPATH is needed for incremental updating. * Gtags check whether or not GPATH exist, since it may be * removed by mistake. */ if (!test("f", makepath(dbpath, dbname(GPATH), NULL))) die("Old version tag file found. Please remake it."); (void)incremental(dbpath, cwd); print_statistics(statistics); exit(0); } /* * create GTAGS and GRTAGS */ createtags(dbpath, cwd); /* * create idutils index. */ if (Iflag) { FILE *op; GFIND *gp; const char *path; tim = statistics_time_start("Time of creating ID"); if (vflag) fprintf(stderr, "[%s] Creating indexes for idutils.\n", now()); strbuf_reset(sb); /* * Since idutils stores the value of PWD in ID file, we need to * force idutils to follow our style. */ #if _WIN32 || __DJGPP__ strbuf_puts(sb, "mkid --files0-from=-"); #else strbuf_sprintf(sb, "PWD=%s mkid --files0-from=-", quote_shell(cwd)); #endif if (vflag) strbuf_puts(sb, " -v"); strbuf_sprintf(sb, " --file=%s/ID", quote_shell(dbpath)); if (vflag) { #ifdef __DJGPP__ if (is_unixy()) /* test for 4DOS as well? */ #endif strbuf_puts(sb, " 1>&2"); } else { strbuf_puts(sb, " >" NULL_DEVICE); #ifdef __DJGPP__ if (is_unixy()) /* test for 4DOS as well? */ #endif strbuf_puts(sb, " 2>&1"); } if (debug) fprintf(stderr, "executing mkid like: %s\n", strbuf_value(sb)); op = popen(strbuf_value(sb), "w"); if (op == NULL) die("cannot execute '%s'.", strbuf_value(sb)); gp = gfind_open(dbpath, NULL, GPATH_BOTH, 0); while ((path = gfind_read(gp)) != NULL) { fputs(path, op); fputc('\0', op); } gfind_close(gp); if (pclose(op) != 0) die("terminated abnormally '%s' (errno = %d).", strbuf_value(sb), errno); if (test("f", makepath(dbpath, "ID", NULL))) if (chmod(makepath(dbpath, "ID", NULL), 0644) < 0) die("cannot chmod ID file."); statistics_time_end(tim); } if (vflag) fprintf(stderr, "[%s] Done.\n", now()); closeconf(); strbuf_close(sb); print_statistics(statistics); return 0; } /** * incremental: incremental update * * @param[in] dbpath dbpath directory * @param[in] root root directory of source tree * @return 0: not updated, 1: updated */ int incremental(const char *dbpath, const char *root) { STATISTICS_TIME *tim; struct stat statp; time_t gtags_mtime; STRBUF *addlist = strbuf_open(0); STRBUF *deletelist = strbuf_open(0); STRBUF *addlist_other = strbuf_open(0); IDSET *deleteset, *findset; int updated = 0; const char *path; unsigned int id, limit; tim = statistics_time_start("Time of inspecting %s and %s.", dbname(GTAGS), dbname(GRTAGS)); if (vflag) { fprintf(stderr, " Tag found in '%s'.\n", dbpath); fprintf(stderr, " Incremental updating.\n"); } /* * get modified time of GTAGS. */ path = makepath(dbpath, dbname(GTAGS), NULL); if (stat(path, &statp) < 0) die("stat failed '%s'.", path); gtags_mtime = statp.st_mtime; if (gpath_open(dbpath, 2) < 0) die("GPATH not found."); /* * deleteset: * The list of the path name which should be deleted from GPATH. * findset: * The list of the path name which exists in the current project. * A project is limited by the --file option. */ deleteset = idset_open(gpath_nextkey()); findset = idset_open(gpath_nextkey()); total = 0; /* * Make add list and delete list for update. */ if (single_update) { int type; const char *fid; if (skipthisfile(single_update)) goto exit; if (test("b", single_update)) goto exit; fid = gpath_path2fid(single_update, &type); if (fid == NULL) { /* new file */ if (!test("f", single_update)) die("'%s' not found.", single_update); type = issourcefile(single_update) ? GPATH_SOURCE : GPATH_OTHER; if (type == GPATH_OTHER) strbuf_puts0(addlist_other, single_update); else { strbuf_puts0(addlist, single_update); total++; } } else if (!test("f", single_update)) { /* delete */ if (type != GPATH_OTHER) { idset_add(deleteset, atoi(fid)); total++; } strbuf_puts0(deletelist, single_update); } else { /* update */ if (type == GPATH_OTHER) goto exit; idset_add(deleteset, atoi(fid)); strbuf_puts0(addlist, single_update); total++; } } else { if (file_list) find_open_filelist(file_list, root, explain); else find_open(NULL, explain); while ((path = find_read()) != NULL) { const char *fid; int n_fid = 0; int other = 0; /* a blank at the head of path means 'NOT SOURCE'. */ if (*path == ' ') { if (test("b", ++path)) continue; other = 1; } if (stat(path, &statp) < 0) die("stat failed '%s'.", path); fid = gpath_path2fid(path, NULL); if (fid) { n_fid = atoi(fid); idset_add(findset, n_fid); } if (other) { if (fid == NULL) strbuf_puts0(addlist_other, path); } else { if (fid == NULL) { strbuf_puts0(addlist, path); total++; } else if (gtags_mtime < statp.st_mtime) { strbuf_puts0(addlist, path); total++; idset_add(deleteset, n_fid); } } } find_close(); /* * make delete list. */ limit = gpath_nextkey(); for (id = 1; id < limit; id++) { char fid[MAXFIDLEN]; int type; snprintf(fid, sizeof(fid), "%d", id); /* * This is a hole of GPATH. The hole increases if the deletion * and the addition are repeated. */ if ((path = gpath_fid2path(fid, &type)) == NULL) continue; /* * The file which does not exist in the findset is treated * assuming that it does not exist in the file system. */ if (type == GPATH_OTHER) { if (!idset_contains(findset, id) || !test("f", path) || test("b", path)) strbuf_puts0(deletelist, path); } else { if (!idset_contains(findset, id) || !test("f", path)) { strbuf_puts0(deletelist, path); idset_add(deleteset, id); } } } } statistics_time_end(tim); /* * execute updating. */ if ((!idset_empty(deleteset) || strbuf_getlen(addlist) > 0) || (strbuf_getlen(deletelist) + strbuf_getlen(addlist_other) > 0)) { int db; updated = 1; tim = statistics_time_start("Time of updating %s and %s.", dbname(GTAGS), dbname(GRTAGS)); if (!idset_empty(deleteset) || strbuf_getlen(addlist) > 0) updatetags(dbpath, root, deleteset, addlist); if (strbuf_getlen(deletelist) + strbuf_getlen(addlist_other) > 0) { const char *start, *end, *p; if (vflag) fprintf(stderr, "[%s] Updating '%s'.\n", now(), dbname(GPATH)); /* gpath_open(dbpath, 2); */ if (strbuf_getlen(deletelist) > 0) { start = strbuf_value(deletelist); end = start + strbuf_getlen(deletelist); for (p = start; p < end; p += strlen(p) + 1) gpath_delete(p); } if (strbuf_getlen(addlist_other) > 0) { start = strbuf_value(addlist_other); end = start + strbuf_getlen(addlist_other); for (p = start; p < end; p += strlen(p) + 1) { gpath_put(p, GPATH_OTHER); } } /* gpath_close(); */ } /* * Update modification time of tag files * because they may have no definitions. */ for (db = GTAGS; db < GTAGLIM; db++) utime(makepath(dbpath, dbname(db), NULL), NULL); statistics_time_end(tim); } exit: if (vflag) { if (updated) fprintf(stderr, " Global databases have been modified.\n"); else fprintf(stderr, " Global databases are up to date.\n"); fprintf(stderr, "[%s] Done.\n", now()); } strbuf_close(addlist); strbuf_close(deletelist); strbuf_close(addlist_other); gpath_close(); idset_close(deleteset); idset_close(findset); return updated; } /** * static void put_syms(int type, const char *tag, int lno, const char *path, const char *line_image, void *arg) * * callback functions for built-in parser */ struct put_func_data { GTOP *gtop[GTAGLIM]; const char *fid; }; static void put_syms(int type, const char *tag, int lno, const char *path, const char *line_image, void *arg) { const struct put_func_data *data = arg; GTOP *gtop; const char *p; /* * sanity checks * These checks are required, because there is no telling what kind of string * comes as 'a symbol' from external plug-in parsers. */ for (p = tag; *p; p++) { if (isspace(*p)) { if (wflag) warning("symbol name includs a space character. (Ignored) [+%d %s]", lno, path); return; } } if (p == tag) { if (wflag) warning("symbol name is null. (Ignored) [+%d %s]", lno, path); return; } if (p - tag >= IDENTLEN) { if (wflag) warning("symbol name is too long. (Ignored) [+%d %s]", lno, path); return; } switch (type) { case PARSER_DEF: gtop = data->gtop[GTAGS]; break; case PARSER_REF_SYM: gtop = data->gtop[GRTAGS]; if (gtop == NULL) return; break; default: return; } gtags_put_using(gtop, tag, lno, data->fid, line_image); } /** * updatetags: update tag file. * * @param[in] dbpath directory in which tag file exist * @param[in] root root directory of source tree * @param[in] deleteset bit array of fid of deleted or modified files * @param[in] addlist '\0' separated list of added or modified files */ void updatetags(const char *dbpath, const char *root, IDSET *deleteset, STRBUF *addlist) { struct put_func_data data; int seqno, flags; const char *path, *start, *end; if (vflag) fprintf(stderr, "[%s] Updating '%s' and '%s'.\n", now(), dbname(GTAGS), dbname(GRTAGS)); /* * Open tag files. */ data.gtop[GTAGS] = gtags_open(dbpath, root, GTAGS, GTAGS_MODIFY, 0); if (test("f", makepath(dbpath, dbname(GRTAGS), NULL))) { data.gtop[GRTAGS] = gtags_open(dbpath, root, GRTAGS, GTAGS_MODIFY, 0); } else { /* * If you set NULL to data.gtop[GRTAGS], parse_file() doesn't write to * GRTAGS. See put_syms(). */ data.gtop[GRTAGS] = NULL; } /* * Delete tags from GTAGS. */ if (!idset_empty(deleteset)) { if (vflag) { char fid[MAXFIDLEN]; int total = idset_count(deleteset); unsigned int id; seqno = 1; for (id = idset_first(deleteset); id != END_OF_ID; id = idset_next(deleteset)) { snprintf(fid, sizeof(fid), "%d", id); path = gpath_fid2path(fid, NULL); if (path == NULL) die("GPATH is corrupted."); fprintf(stderr, " [%d/%d] deleting tags of %s\n", seqno++, total, path + 2); } } gtags_delete(data.gtop[GTAGS], deleteset); if (data.gtop[GRTAGS] != NULL) gtags_delete(data.gtop[GRTAGS], deleteset); } /* * Set flags. */ data.gtop[GTAGS]->flags = 0; if (extractmethod) data.gtop[GTAGS]->flags |= GTAGS_EXTRACTMETHOD; data.gtop[GRTAGS]->flags = data.gtop[GTAGS]->flags; flags = 0; if (vflag) flags |= PARSER_VERBOSE; if (debug) flags |= PARSER_DEBUG; if (wflag) flags |= PARSER_WARNING; if (explain) flags |= PARSER_EXPLAIN; if (getenv("GTAGSFORCEENDBLOCK")) flags |= PARSER_END_BLOCK; /* * Add tags to GTAGS and GRTAGS. */ start = strbuf_value(addlist); end = start + strbuf_getlen(addlist); seqno = 0; for (path = start; path < end; path += strlen(path) + 1) { gpath_put(path, GPATH_SOURCE); data.fid = gpath_path2fid(path, NULL); if (data.fid == NULL) die("GPATH is corrupted.('%s' not found)", path); if (vflag) fprintf(stderr, " [%d/%d] extracting tags of %s\n", ++seqno, total, path + 2); parse_file(path, flags, put_syms, &data); gtags_flush(data.gtop[GTAGS], data.fid); if (data.gtop[GRTAGS] != NULL) gtags_flush(data.gtop[GRTAGS], data.fid); } parser_exit(); gtags_close(data.gtop[GTAGS]); if (data.gtop[GRTAGS] != NULL) gtags_close(data.gtop[GRTAGS]); } /** * createtags: create tags file * * @param[in] dbpath dbpath directory * @param[in] root root directory of source tree */ void createtags(const char *dbpath, const char *root) { STATISTICS_TIME *tim; STRBUF *sb = strbuf_open(0); struct put_func_data data; int openflags, flags, seqno; const char *path; tim = statistics_time_start("Time of creating %s and %s.", dbname(GTAGS), dbname(GRTAGS)); if (vflag) fprintf(stderr, "[%s] Creating '%s' and '%s'.\n", now(), dbname(GTAGS), dbname(GRTAGS)); openflags = cflag ? GTAGS_COMPACT : 0; #ifdef USE_SQLITE3 if (use_sqlite3) openflags |= GTAGS_SQLITE3; #endif data.gtop[GTAGS] = gtags_open(dbpath, root, GTAGS, GTAGS_CREATE, openflags); data.gtop[GTAGS]->flags = 0; if (extractmethod) data.gtop[GTAGS]->flags |= GTAGS_EXTRACTMETHOD; data.gtop[GRTAGS] = gtags_open(dbpath, root, GRTAGS, GTAGS_CREATE, openflags); data.gtop[GRTAGS]->flags = data.gtop[GTAGS]->flags; flags = 0; if (vflag) flags |= PARSER_VERBOSE; if (debug) flags |= PARSER_DEBUG; if (wflag) flags |= PARSER_WARNING; if (explain) flags |= PARSER_EXPLAIN; if (getenv("GTAGSFORCEENDBLOCK")) flags |= PARSER_END_BLOCK; /* * Add tags to GTAGS and GRTAGS. */ if (file_list) find_open_filelist(file_list, root, explain); else find_open(NULL, explain); seqno = 0; while ((path = find_read()) != NULL) { if (*path == ' ') { path++; if (!test("b", path)) gpath_put(path, GPATH_OTHER); continue; } gpath_put(path, GPATH_SOURCE); data.fid = gpath_path2fid(path, NULL); if (data.fid == NULL) die("GPATH is corrupted.('%s' not found)", path); seqno++; if (vflag) fprintf(stderr, " [%d] extracting tags of %s\n", seqno, path + 2); parse_file(path, flags, put_syms, &data); gtags_flush(data.gtop[GTAGS], data.fid); gtags_flush(data.gtop[GRTAGS], data.fid); } total = seqno; parser_exit(); find_close(); statistics_time_end(tim); tim = statistics_time_start("Time of flushing B-tree cache"); gtags_close(data.gtop[GTAGS]); gtags_close(data.gtop[GRTAGS]); statistics_time_end(tim); strbuf_reset(sb); if (getconfs("GTAGS_extra", sb)) { tim = statistics_time_start("Time of executing GTAGS_extra command"); if (system(strbuf_value(sb))) fprintf(stderr, "GTAGS_extra command failed: %s\n", strbuf_value(sb)); statistics_time_end(tim); } strbuf_reset(sb); if (getconfs("GRTAGS_extra", sb)) { tim = statistics_time_start("Time of executing GRTAGS_extra command"); if (system(strbuf_value(sb))) fprintf(stderr, "GRTAGS_extra command failed: %s\n", strbuf_value(sb)); statistics_time_end(tim); } strbuf_close(sb); }