/* * Copyright (c) 2002, 2004, 2005, 2008, 2015, 2016, 2017 * 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 #ifdef STDC_HEADERS #include #endif #ifdef HAVE_STRING_H #include #else #include #endif #include "checkalloc.h" #include "die.h" #include "locatestring.h" #include "strbuf.h" #include "strmake.h" #include "strhash.h" #include "langmap.h" #include "varray.h" #include "fnmatch.h" static void trim_suffix_list(STRBUF *, STRHASH *); static int match_suffix_list(const char *, const char *, const char *); STATIC_STRBUF(lastmatch); static STRBUF *active_map; static int wflag; /** * set warning flag on. */ void set_langmap_wflag() { wflag = 1; } /** * construct language map. * * copy string langmap (map) and convert it to language map like this: * * langmap (string) "c:.c.h,java:.java,cpp:.C.H" * | * v * language map c\0.c.h\0java\0.java\0cpp\0.C.H\0 */ void setup_langmap(const char *map) { char *p; int onsuffix = 0; /* not on suffix string */ active_map = strbuf_open(0); strbuf_puts(active_map, map); for (p = strbuf_value(active_map); *p; p++) { /* * "c:.c.h,java:.java,cpp:.C.H" */ if ((onsuffix == 0 && *p == ',') || (onsuffix == 1 && *p == ':')) die_with_code(2, "syntax error in langmap '%s'.", map); if (*p == ':' || *p == ',') { onsuffix ^= 1; *p = '\0'; } } if (onsuffix == 0) die_with_code(2, "syntax error in langmap '%s'.", map); /* strbuf_close(active_map); */ } /** * trim suffix list * * Remove duplicated suffixs from the suffix list. */ static void trim_suffix_list(STRBUF *list, STRHASH *hash) { STATIC_STRBUF(sb); const char *p; strbuf_clear(sb); strbuf_puts(sb, strbuf_value(list)); strbuf_reset(list); p = strbuf_value(sb); while (*p) { STATIC_STRBUF(suffix); struct sh_entry *sh; strbuf_clear(suffix); switch (*p) { case '.': strbuf_putc(suffix, *p); for (p++; *p && *p != '.'; p++) strbuf_putc(suffix, *p); break; case '(': strbuf_putc(suffix, *p); for (p++; *p && *p != ')'; p++) strbuf_putc(suffix, *p); if (!*p) die_with_code(2, "syntax error in the suffix list '%s'.", strbuf_value(sb)); strbuf_putc(suffix, *p++); break; default: die_with_code(2, "syntax error in the suffix list '%s'.", strbuf_value(sb)); break; } if ((sh = strhash_assign(hash, strbuf_value(suffix), 0)) != NULL) { if (!sh->value && wflag) warning("langmap: suffix '%s' is duplicated. all except for the head is ignored.", strbuf_value(suffix)); sh->value = (void *)1; } else { strbuf_puts(list, strbuf_value(suffix)); (void)strhash_assign(hash, strbuf_value(suffix), 1); } } } /* * merge and trim a langmap * * (1) duplicated suffixes except for the first one are ignored. * (2) one more entries which belong to a language are gathered by one. * * Example: * C++:.cpp.c++,Java:.java.cpp,C++:.inl * | ----(1) ----(2) * v * C++:.cpp.c++.inl,Java:.java */ const char * trim_langmap(const char *map) { typedef struct { char *name; /* language: C++ */ char *list; /* suffixes: .cpp.c++ */ } SUFFIX; STATIC_STRBUF(sb); const char *p = map; STRBUF *name = strbuf_open(0); STRBUF *list = strbuf_open(0); STRHASH *hash = strhash_open(10); VARRAY *vb = varray_open(sizeof(SUFFIX), 32); SUFFIX *ent = NULL; int i; strbuf_clear(sb); while (*p) { strbuf_reset(name); strbuf_reset(list); strbuf_puts(name, strmake(p, ":")); p += strbuf_getlen(name) + 1; strbuf_puts(list, strmake(p, ",")); p += strbuf_getlen(list); if (*p) p++; if (strbuf_getlen(name) == 0) die_with_code(2, "syntax error in langmap '%s'.", map); if (strchr(strbuf_value(name), ',')) die_with_code(2, "syntax error in langmap '%s'.", map); /* * ignores duplicated suffixes. */ trim_suffix_list(list, hash); if (strbuf_getlen(list) == 0) continue; /* * examine whether it appeared already. */ ent = NULL; for (i = 0; i < vb->length; i++) { SUFFIX *ent0 = varray_assign(vb, i, 0); if (!strcmp(ent0->name, strbuf_value(name))) { ent = ent0; break; } } if (ent == NULL) { /* set initial values to a new entry */ ent = varray_append(vb); ent->name = check_strdup(strbuf_value(name)); ent->list = check_strdup(strbuf_value(list)); } else { /* append values to the entry */ ent->list = check_realloc(ent->list, strlen(ent->list) + strbuf_getlen(list) + 1); strcat(ent->list, strbuf_value(list)); } } for (i = 0; i < vb->length; i++) { ent = varray_assign(vb, i, 0); if (i > 0) strbuf_putc(sb, ','); strbuf_puts(sb, ent->name); strbuf_putc(sb, ':'); strbuf_puts(sb, ent->list); free(ent->name); free(ent->list); } strbuf_close(name); strbuf_close(list); strhash_close(hash); varray_close(vb); return strbuf_value(sb); } /** * decide language of the suffix. * * Though '*.h' files are shared by C and C++, GLOBAL treats them * as C source files by default. If you set an environment variable * 'GTAGSFORCECPP' then C++ parser will be invoked. */ const char * decide_lang(const char *suffix) { const char *lang, *list, *tail; /* * Though '*.h' files are shared by C and C++, GLOBAL treats them * as C source files by default. If you set an environment variable * 'GTAGS_FORCECPP' then C++ parser will be invoked. */ if (!strcmp(suffix, ".h") && getenv("GTAGSFORCECPP") != NULL) { strbuf_clear(lastmatch); strbuf_puts(lastmatch, ".h"); return "cpp"; } lang = strbuf_value(active_map); tail = lang + strbuf_getlen(active_map); /* check whether or not list includes suffix. */ while (lang < tail) { list = lang + strlen(lang) + 1; if (match_suffix_list(suffix, NULL, list)) return lang; lang = list + strlen(list) + 1; } return NULL; } /** * decide language of the path. */ const char * decide_lang_path(const char *path) { const char *lang, *list, *tail; const char *suffix = locatestring(path, ".", MATCH_LAST); const char *basename = locatestring(path, "/", MATCH_LAST); if (basename) basename++; /* * Though '*.h' files are shared by C and C++, GLOBAL treats them * as C source files by default. If you set an environment variable * 'GTAGS_FORCECPP' then C++ parser will be invoked. */ if (!strcmp(suffix, ".h") && getenv("GTAGSFORCECPP") != NULL) { strbuf_clear(lastmatch); strbuf_puts(lastmatch, ".h"); return "cpp"; } lang = strbuf_value(active_map); tail = lang + strbuf_getlen(active_map); /* check whether or not list includes suffix. */ while (lang < tail) { list = lang + strlen(lang) + 1; if (match_suffix_list(suffix, basename, list)) return lang; lang = list + strlen(list) + 1; } return NULL; } /** * return true if the suffix exists in the list. * suffix may include '()'. */ const char * get_last_match() { return strbuf_value(lastmatch); } static int match_suffix_list(const char *suffix, const char *basename, const char *list) { const char *p; strbuf_clear(lastmatch); suffix++; /* skip '.' */ /* * list includes suffixes and/or patterns. */ while (*list) { if (*list == '.') { p = strmake(++list, ".("); if (locatestring(p, suffix, MATCH_COMPLETE #if defined(_WIN32) || defined(__DJGPP__) |IGNORE_CASE #endif )) { strbuf_putc(lastmatch, '.'); strbuf_puts(lastmatch, p); return 1; } list += strlen(p); } else if (*list == '(') { p = strmake(++list, ")"); if (basename && fnmatch(p, basename, 0) == 0) { strbuf_putc(lastmatch, '('); strbuf_puts(lastmatch, p); strbuf_putc(lastmatch, ')'); return 1; } list += strlen(p) + 1; } } return 0; }