/* * Copyright (c) 1997, 1998, 1999, 2000, 2002, 2008, 2011, 2014, 2015 * 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 #ifdef STDC_HEADERS #include #endif #ifdef HAVE_STRING_H #include #else #include #endif #ifdef HAVE_UNISTD_H #include #endif #include "gparam.h" #include "abs2rel.h" #include "die.h" #include "getdbpath.h" #include "gtagsop.h" #include "locatestring.h" #include "makepath.h" #include "path.h" #include "strlimcpy.h" #include "test.h" /** * define the position of the root slash. */ #if defined(_WIN32) || defined(__DJGPP__) #define ROOT 2 #else #define ROOT 0 #endif static const char *gtagsobjdirprefix; /**< tag partition */ static const char *gtagsobjdir; /**< tag directory */ char const *gtags_dbpath_error; /**< error message */ /** * setupvariables: load variables regard to BSD OBJ directory. */ static void setupvariables(int verbose) { const char *p; if ((p = getenv("GTAGSOBJDIRPREFIX")) != NULL || (p = getenv("MAKEOBJDIRPREFIX")) != NULL) { gtagsobjdirprefix = p; if (verbose) fprintf(stderr, "GTAGSOBJDIRPREFIX is set to '%s'.\n", p); } else { gtagsobjdirprefix = "/usr/obj"; } if ((p = getenv("GTAGSOBJDIR")) != NULL || (p = getenv("MAKEOBJDIR")) != NULL) { gtagsobjdir = p; if (verbose) fprintf(stderr, "GTAGSOBJDIR is set to '%s'.\n", p); } else { gtagsobjdir = "obj"; } } /** * getobjdir: get objdir if it exists. * * @param[in] candidate candidate root directory * @param[in] verbose verbose mode 1: on, 0: off * @return objdir(NULL: not found) */ char * getobjdir(const char *candidate, int verbose) { static char path[MAXPATHLEN]; /* * setup gtagsobjdir and gtagsobjdirprefix (only first time). */ if (gtagsobjdir == NULL) setupvariables(0); snprintf(path, sizeof(path), "%s/%s", candidate, gtagsobjdir); if (test("d", path)) { if (!test("drw", path)) die("Found objdir '%s', but you don't have read/write permission for it.", path); if (verbose) fprintf(stderr, "Using objdir '%s'.\n", path); return path; } #if !defined(_WIN32) && !defined(__DJGPP__) if (test("d", gtagsobjdirprefix)) { snprintf(path, sizeof(path), "%s%s", gtagsobjdirprefix, candidate); if (test("d", path)) { if (!test("drw", path)) die("Found objdir '%s', but you don't have read/write permission for it.", path); if (verbose) fprintf(stderr, "Using objdir '%s'.\n", path); return path; } if (makedirectories(gtagsobjdirprefix, candidate + 1, verbose) < 0) die("Found the base for objdir '%s', but you cannot create new directory in it.", path); if (verbose) fprintf(stderr, "Using objdir '%s'.\n", path); return path; } #endif return NULL; } /** * gtagsexist: test whether GTAGS's existence. * * @param[in] candidate candidate root directory * @param[out] dbpath directory which "GTAGS" exist * @param[in] size size of dbpath buffer * @param[in] verbose verbose mode 1: on, 0: off * @return 0: not found, 1: found * * Gtagsexist locate "GTAGS" file in "$candidate/", "$candidate/obj/" and * "/usr/obj/$candidate/" in this order by default. * This behavior is same with BSD make(1)'s one. */ int gtagsexist(const char *candidate, char *dbpath, int size, int verbose) { char path[MAXPATHLEN]; const char *candidate_without_slash; /* * setup gtagsobjdir and gtagsobjdirprefix (only first time). */ if (gtagsobjdir == NULL) setupvariables(verbose); if (strcmp(candidate, "/") == 0) candidate_without_slash = ""; else candidate_without_slash = candidate; snprintf(path, sizeof(path), "%s/%s", candidate_without_slash, dbname(GTAGS)); if (verbose) fprintf(stderr, "checking %s\n", path); if (test("fr", path)) { if (verbose) fprintf(stderr, "GTAGS found at '%s'.\n", path); snprintf(dbpath, size, "%s", candidate); return 1; } snprintf(path, sizeof(path), "%s/%s/%s", candidate_without_slash, gtagsobjdir, dbname(GTAGS)); if (verbose) fprintf(stderr, "checking %s\n", path); if (test("fr", path)) { if (verbose) fprintf(stderr, "GTAGS found at '%s'.\n", path); snprintf(dbpath, size, "%s/%s", candidate_without_slash, gtagsobjdir); return 1; } #if !defined(_WIN32) && !defined(__DJGPP__) snprintf(path, sizeof(path), "%s%s/%s", gtagsobjdirprefix, candidate_without_slash, dbname(GTAGS)); if (verbose) fprintf(stderr, "checking %s\n", path); if (test("fr", path)) { if (verbose) fprintf(stderr, "GTAGS found at '%s'.\n", path); snprintf(dbpath, size, "%s%s", gtagsobjdirprefix, candidate_without_slash); return 1; } #endif return 0; } static char dbpath[MAXPATHLEN]; static char root[MAXPATHLEN]; static char root_with_slash[MAXPATHLEN]; static char cwd[MAXPATHLEN]; static char relative_cwd_with_slash[MAXPATHLEN+2]; /* * setupdbpath: setup dbpath directory * * @param[in] verbose verbose mode 1: on, 0: off * @return 0: normal, 0<: error * Globals used (output): * cwd: current directory, * root: root of source tree, * dbpath: directory which "GTAGS" exist, * gtags_dbpath_error: set if status (return value) < 0 * */ int setupdbpath(int verbose) { struct stat sb; char *p; static char msg[1024]; if (!vgetcwd(cwd, MAXPATHLEN)) { gtags_dbpath_error = "cannot get current directory."; return -1; } canonpath(cwd); if ((p = getenv("GTAGSROOT")) != NULL) { if (verbose) fprintf(stderr, "GTAGSROOT is set to '%s'.\n", p); if (!isabspath(p)) { gtags_dbpath_error = "GTAGSROOT must be an absolute path."; return -1; } if (stat(p, &sb) || !S_ISDIR(sb.st_mode)) { snprintf(msg, sizeof(msg), "directory '%s' not found.", p); gtags_dbpath_error = msg; return -1; } if (getenv("GTAGSLOGICALPATH")) { strlimcpy(root, p, sizeof(root)); } else { if (realpath(p, root) == NULL) { snprintf(msg, sizeof(msg), "cannot get real path of '%s'.", p); gtags_dbpath_error = msg; return -1; } } /* * GTAGSDBPATH is meaningful only when GTAGSROOT exist. */ if ((p = getenv("GTAGSDBPATH")) != NULL) { if (verbose) fprintf(stderr, "GTAGSDBPATH is set to '%s'.\n", p); if (!isabspath(p)) { gtags_dbpath_error = "GTAGSDBPATH must be an absolute path."; return -1; } if (stat(p, &sb) || !S_ISDIR(sb.st_mode)) { snprintf(msg, sizeof(msg), "directory '%s' not found.", p); gtags_dbpath_error = msg; return -1; } strlimcpy(dbpath, getenv("GTAGSDBPATH"), MAXPATHLEN); } else { if (!gtagsexist(root, dbpath, MAXPATHLEN, verbose)) { gtags_dbpath_error = "GTAGS not found."; return -3; } } } else { if (verbose && getenv("GTAGSDBPATH")) fprintf(stderr, "warning: GTAGSDBPATH is ignored because GTAGSROOT is not set.\n"); /* * start from current directory to '/' directory. */ strlimcpy(root, cwd, MAXPATHLEN); p = root + strlen(root); while (!gtagsexist(root, dbpath, MAXPATHLEN, verbose)) { if (!strcmp(root+ROOT, "/")) { /* reached the system's root directory */ *(root+ROOT) = '\0'; break; } while (*--p != '/' && p > (root+ROOT)) ; if (p == (root+ROOT)) p++; *p = 0; } if (*(root+ROOT) == 0) { gtags_dbpath_error = "GTAGS not found."; return -3; } /* * If file 'GTAGSROOT' found without environment variable * GTAGSDBPATH, use the value of it as GTAGSROOT. */ do { FILE *fp; STRBUF *sb; const char *s, *path; path = makepath(root, "GTAGSROOT", NULL); if (!test("fr", path)) { break; } fp = fopen(path, "r"); if (fp == NULL) { if (verbose) fprintf(stderr, "'%s' ignored because it cannot be opened.\n", path); break; } sb = strbuf_open(0); s = strbuf_fgets(sb, fp, STRBUF_NOCRLF); if (s == NULL) { /* Empty file? */ if (verbose) fprintf(stderr, "'%s' ignored; strbuf_fgets() returned NULL.\n", path); goto ignore_lab; } if (!test("d", s)) { /* XXX: if s == NULL, test() will use previous path used. */ if (verbose) fprintf(stderr, "'%s' ignored because it doesn't include existent directory name.\n", path); } else { char buf[MAXPATHLEN]; if (verbose) fprintf(stderr, "GTAGSROOT found at '%s'.\n", path); if (!isabspath(s)) s = realpath(makepath(root, s, NULL), buf); strlimcpy(root, s, MAXPATHLEN); } ignore_lab:; fclose(fp); strbuf_close(sb); break; } while (0); } if (!strcmp(root+ROOT, "/")) strlimcpy(root_with_slash, root, sizeof(root_with_slash)); else snprintf(root_with_slash, sizeof(root_with_slash), "%s/", root); /* * relative from the project root directory. */ snprintf(relative_cwd_with_slash, sizeof(relative_cwd_with_slash), "./%s/", cwd + strlen(root) + 1); return 0; } /** * in_the_project: test whether path is in the project. * * @param[in] path target file or directory * @return 0: out of the project, 1: in the project * * [Note] Please pass an absolute path name which does not include "." (current directory) or * ".." (parent directory). */ int in_the_project(const char *path) { if (!strcmp(path, root) || locatestring(path, root_with_slash, MATCH_AT_FIRST)) return 1; return 0; } /* * return saved values. */ const char * get_dbpath(void) { return (const char *)dbpath; } const char * get_root(void) { return (const char *)root; } const char * get_root_with_slash(void) { return (const char *)root_with_slash; } const char * get_cwd(void) { return (const char *)cwd; } const char * get_relative_cwd_with_slash(void) { return (const char *)relative_cwd_with_slash; } void dump_dbpath(void) { fprintf(stderr, "db path: %s\n", dbpath); fprintf(stderr, "root path: %s\n", root); fprintf(stderr, "current directory: %s\n", cwd); }