From a2ecdab6d79b19806a5be3feae2058292620f0cc Mon Sep 17 00:00:00 2001 From: =?utf8?q?Ji=C5=99=C3=AD=20Techet?= Date: Wed, 18 Nov 2020 12:44:07 -0800 Subject: [PATCH] Update TM to use latest universal ctags Introduce new tm_ctags.c/h files which roughly correspond to the previously used ctags-api.c/h files and which serve as an interface between ctags and Geany. Move init_tag() and update_python_arglist() from tm_source_file.c to tm_ctags.c. Use the new functions from tm_ctags in the rest of the tag manager. Define external parser list inside tm_parsers.h which is injected to ctags using the EXTERNAL_PARSER_LIST macro. --- src/tagmanager/Makefile.am | 5 +- src/tagmanager/tm_ctags.c | 275 ++++++++++++++++++++++++++++++++++++++++ src/tagmanager/tm_ctags.h | 34 +++++ src/tagmanager/tm_parser.c | 21 ++- src/tagmanager/tm_parser.h | 2 +- src/tagmanager/tm_parsers.h | 70 ++++++++++ src/tagmanager/tm_source_file.c | 133 ++----------------- src/tagmanager/tm_source_file.h | 4 + src/tagmanager/tm_tag.c | 2 +- src/tagmanager/tm_workspace.c | 10 +- 10 files changed, 412 insertions(+), 144 deletions(-) create mode 100644 src/tagmanager/tm_ctags.c create mode 100644 src/tagmanager/tm_ctags.h create mode 100644 src/tagmanager/tm_parsers.h diff --git a/src/tagmanager/Makefile.am b/src/tagmanager/Makefile.am index e286961ec..066192b95 100644 --- a/src/tagmanager/Makefile.am +++ b/src/tagmanager/Makefile.am @@ -17,9 +17,12 @@ tagmanager_include_HEADERS = \ tm_parser.h -libtagmanager_la_SOURCES =\ +libtagmanager_la_SOURCES = \ + tm_ctags.h \ + tm_ctags.c \ tm_parser.h \ tm_parser.c \ + tm_parsers.h \ tm_source_file.h \ tm_source_file.c \ tm_tag.h \ diff --git a/src/tagmanager/tm_ctags.c b/src/tagmanager/tm_ctags.c new file mode 100644 index 000000000..015bca569 --- /dev/null +++ b/src/tagmanager/tm_ctags.c @@ -0,0 +1,275 @@ +/* +* Copyright (c) 2016, Jiri Techet +* +* This source code is released for free distribution under the terms of the +* GNU General Public License version 2 or (at your option) any later version. +* +* Encapsulates ctags so it is isolated from the rest of Geany. +*/ + +#include "tm_ctags.h" +#include "tm_tag.h" + +#include "general.h" /* must always come before the rest of ctags headers */ +#include "entry_p.h" +#include "error_p.h" +#include "field_p.h" +#include "options_p.h" +#include "parse_p.h" +#include "trashbox_p.h" +#include "writer_p.h" +#include "xtag_p.h" + +#include + + +static gint write_entry(tagWriter *writer, MIO * mio, const tagEntryInfo *const tag, void *user_data); +static void rescan_failed(tagWriter *writer, gulong valid_tag_num, void *user_data); + +tagWriter geanyWriter = { + .writeEntry = write_entry, + .writePtagEntry = NULL, /* no pseudo-tags */ + .preWriteEntry = NULL, + .postWriteEntry = NULL, + .rescanFailedEntry = rescan_failed, + .treatFieldAsFixed = NULL, + .defaultFileName = "geany_tags_file_which_should_never_appear_anywhere", + .private = NULL, + .type = WRITER_CUSTOM +}; + + +static bool nonfatal_error_printer(const errorSelection selection, + const gchar *const format, + va_list ap, void *data CTAGS_ATTR_UNUSED) +{ + g_logv(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, format, ap); + + return false; +} + + +static void enable_all_lang_kinds() +{ + TMParserType lang; + + for (lang = 0; lang < countParsers(); lang++) + { + guint kind_num = countLanguageKinds(lang); + guint kind; + + for (kind = 0; kind < kind_num; kind++) + { + kindDefinition *def = getLanguageKind(lang, kind); + enableKind(def, true); + } + } +} + + +/* + Initializes a TMTag structure with information from a ctagsTag struct + used by the ctags parsers. Note that the TMTag structure must be malloc()ed + before calling this function. + @param tag The TMTag structure to initialize + @param file Pointer to a TMSourceFile struct (it is assigned to the file member) + @param tag_entry Tag information gathered by the ctags parser + @return TRUE on success, FALSE on failure +*/ +static gboolean init_tag(TMTag *tag, TMSourceFile *file, const tagEntryInfo *tag_entry) +{ + TMTagType type; + guchar kind_letter; + TMParserType lang; + + if (!tag_entry) + return FALSE; + + lang = tag_entry->langType; + kind_letter = getLanguageKind(tag_entry->langType, tag_entry->kindIndex)->letter; + type = tm_parser_get_tag_type(kind_letter, lang); + if (file->lang != lang) /* this is a tag from a subparser */ + { + /* check for possible re-definition of subparser type */ + type = tm_parser_get_subparser_type(file->lang, lang, type); + } + + if (!tag_entry->name || type == tm_tag_undef_t) + return FALSE; + + tag->name = g_strdup(tag_entry->name); + tag->type = type; + tag->local = tag_entry->isFileScope; + tag->pointerOrder = 0; /* backward compatibility (use var_type instead) */ + tag->line = tag_entry->lineNumber; + if (NULL != tag_entry->extensionFields.signature) + tag->arglist = g_strdup(tag_entry->extensionFields.signature); + if ((NULL != tag_entry->extensionFields.scopeName) && + (0 != tag_entry->extensionFields.scopeName[0])) + tag->scope = g_strdup(tag_entry->extensionFields.scopeName); + if (tag_entry->extensionFields.inheritance != NULL) + tag->inheritance = g_strdup(tag_entry->extensionFields.inheritance); + if (tag_entry->extensionFields.typeRef[1] != NULL) + tag->var_type = g_strdup(tag_entry->extensionFields.typeRef[1]); + if (tag_entry->extensionFields.access != NULL) + tag->access = tm_source_file_get_tag_access(tag_entry->extensionFields.access); + if (tag_entry->extensionFields.implementation != NULL) + tag->impl = tm_source_file_get_tag_impl(tag_entry->extensionFields.implementation); + if ((tm_tag_macro_t == tag->type) && (NULL != tag->arglist)) + tag->type = tm_tag_macro_with_arg_t; + tag->file = file; + /* redefine lang also for subparsers because the rest of Geany assumes that + * tags from a single file are from a single language */ + tag->lang = file->lang; + return TRUE; +} + + +/* add argument list of __init__() Python methods to the class tag */ +static void update_python_arglist(const TMTag *tag, TMSourceFile *source_file) +{ + guint i; + const gchar *parent_tag_name; + + if (tag->type != tm_tag_method_t || tag->scope == NULL || + g_strcmp0(tag->name, "__init__") != 0) + return; + + parent_tag_name = strrchr(tag->scope, '.'); + if (parent_tag_name) + parent_tag_name++; + else + parent_tag_name = tag->scope; + + /* going in reverse order because the tag was added recently */ + for (i = source_file->tags_array->len; i > 0; i--) + { + TMTag *prev_tag = (TMTag *) source_file->tags_array->pdata[i - 1]; + if (g_strcmp0(prev_tag->name, parent_tag_name) == 0) + { + g_free(prev_tag->arglist); + prev_tag->arglist = g_strdup(tag->arglist); + break; + } + } +} + + +static gint write_entry(tagWriter *writer, MIO * mio, const tagEntryInfo *const tag, void *user_data) +{ + TMSourceFile *source_file = user_data; + TMTag *tm_tag = tm_tag_new(); + + getTagScopeInformation((tagEntryInfo *)tag, NULL, NULL); + + if (!init_tag(tm_tag, source_file, tag)) + { + tm_tag_unref(tm_tag); + return 0; + } + + if (tm_tag->lang == TM_PARSER_PYTHON) + update_python_arglist(tm_tag, source_file); + + g_ptr_array_add(source_file->tags_array, tm_tag); + + /* output length - we don't write anything to the MIO */ + return 0; +} + + +static void rescan_failed(tagWriter *writer, gulong valid_tag_num, void *user_data) +{ + TMSourceFile *source_file = user_data; + GPtrArray *tags_array = source_file->tags_array; + + if (tags_array->len > valid_tag_num) + { + guint i; + for (i = valid_tag_num; i < tags_array->len; i++) + tm_tag_unref(tags_array->pdata[i]); + g_ptr_array_set_size(tags_array, valid_tag_num); + } +} + + +/* keep in sync with ctags main() - use only things interesting for us */ +void tm_ctags_init(void) +{ + initDefaultTrashBox(); + + setErrorPrinter(nonfatal_error_printer, NULL); + setTagWriter(WRITER_CUSTOM, &geanyWriter); + + checkRegex(); + initFieldObjects(); + initXtagObjects(); + + initializeParsing(); + initOptions(); + + /* make sure all parsers are initialized */ + initializeParser(LANG_AUTO); + + /* change default values which are false */ + enableXtag(XTAG_TAGS_GENERATED_BY_GUEST_PARSERS, true); + enableXtag(XTAG_REFERENCE_TAGS, true); + + /* some kinds we are interested in are disabled by default */ + enable_all_lang_kinds(); +} + + +void tm_ctags_parse(guchar *buffer, gsize buffer_size, + const gchar *file_name, TMParserType language, TMSourceFile *source_file) +{ + g_return_if_fail(buffer != NULL || file_name != NULL); + + parseRawBuffer(file_name, buffer, buffer_size, language, source_file); +} + + +const gchar *tm_ctags_get_lang_name(TMParserType lang) +{ + return getLanguageName(lang); +} + + +TMParserType tm_ctags_get_named_lang(const gchar *name) +{ + return getNamedLanguage(name, 0); +} + + +const gchar *tm_ctags_get_lang_kinds(TMParserType lang) +{ + guint kind_num = countLanguageKinds(lang); + static gchar kinds[257]; + guint i; + + for (i = 0; i < kind_num; i++) + kinds[i] = getLanguageKind(lang, i)->letter; + kinds[i] = '\0'; + + return kinds; +} + + +const gchar *tm_ctags_get_kind_name(gchar kind, TMParserType lang) +{ + kindDefinition *def = getLanguageKindForLetter(lang, kind); + return def ? def->name : "unknown"; +} + + +gchar tm_ctags_get_kind_from_name(const gchar *name, TMParserType lang) +{ + kindDefinition *def = getLanguageKindForName(lang, name); + return def ? def->letter : '-'; +} + + +guint tm_ctags_get_lang_count(void) +{ + return countParsers(); +} diff --git a/src/tagmanager/tm_ctags.h b/src/tagmanager/tm_ctags.h new file mode 100644 index 000000000..217baf36f --- /dev/null +++ b/src/tagmanager/tm_ctags.h @@ -0,0 +1,34 @@ +/* +* Copyright (c) 2016, Jiri Techet +* +* This source code is released for free distribution under the terms of the +* GNU General Public License version 2 or (at your option) any later version. +* +* Encapsulates ctags so it is isolated from the rest of Geany. +*/ +#ifndef TM_CTAGS_H +#define TM_CTAGS_H + +#include + +#include "tm_source_file.h" + +G_BEGIN_DECLS + +#ifdef GEANY_PRIVATE + +void tm_ctags_init(void); +void tm_ctags_parse(guchar *buffer, gsize buffer_size, + const gchar *file_name, TMParserType language, TMSourceFile *source_file); +const gchar *tm_ctags_get_lang_name(TMParserType lang); +TMParserType tm_ctags_get_named_lang(const gchar *name); +const gchar *tm_ctags_get_lang_kinds(TMParserType lang); +const gchar *tm_ctags_get_kind_name(gchar kind, TMParserType lang); +gchar tm_ctags_get_kind_from_name(const gchar *name, TMParserType lang); +guint tm_ctags_get_lang_count(void); + +#endif /* GEANY_PRIVATE */ + +G_END_DECLS + +#endif /* TM_CTAGS_H */ diff --git a/src/tagmanager/tm_parser.c b/src/tagmanager/tm_parser.c index 7d008e5f6..9d4ae22c1 100644 --- a/src/tagmanager/tm_parser.c +++ b/src/tagmanager/tm_parser.c @@ -19,7 +19,7 @@ */ #include "tm_parser.h" -#include "ctags-api.h" +#include "tm_ctags.h" #include @@ -691,28 +691,23 @@ void tm_parser_verify_type_mappings(void) { TMParserType lang; - if (TM_PARSER_COUNT > ctagsGetLangCount()) + if (TM_PARSER_COUNT > tm_ctags_get_lang_count()) g_error("More parsers defined in Geany than in ctags"); for (lang = 0; lang < TM_PARSER_COUNT; lang++) { - const gchar *kinds = ctagsGetLangKinds(lang); + const gchar *kinds = tm_ctags_get_lang_kinds(lang); TMParserMap *map = &parser_map[lang]; gchar presence_map[256]; guint i; if (! map->entries || map->size < 1) g_error("No tag types in TM for %s, is the language listed in parser_map?", - ctagsGetLangName(lang)); - - /* TODO: check also regex parser mappings. At the moment there's no way - * to access regex parser definitions in ctags */ - if (ctagsIsUsingRegexParser(lang)) - continue; + tm_ctags_get_lang_name(lang)); if (map->size != strlen(kinds)) g_error("Different number of tag types in TM (%d) and ctags (%d) for %s", - map->size, (int)strlen(kinds), ctagsGetLangName(lang)); + map->size, (int)strlen(kinds), tm_ctags_get_lang_name(lang)); memset(presence_map, 0, sizeof(presence_map)); for (i = 0; i < map->size; i++) @@ -734,10 +729,10 @@ void tm_parser_verify_type_mappings(void) } if (!ctags_found) g_error("Tag type '%c' found in TM but not in ctags for %s", - map->entries[i].kind, ctagsGetLangName(lang)); + map->entries[i].kind, tm_ctags_get_lang_name(lang)); if (!tm_found) g_error("Tag type '%c' found in ctags but not in TM for %s", - kinds[i], ctagsGetLangName(lang)); + kinds[i], tm_ctags_get_lang_name(lang)); presence_map[(unsigned char) map->entries[i].kind]++; } @@ -746,7 +741,7 @@ void tm_parser_verify_type_mappings(void) { if (presence_map[i] > 1) g_error("Duplicate tag type '%c' found for %s", - (gchar)i, ctagsGetLangName(lang)); + (gchar)i, tm_ctags_get_lang_name(lang)); } } } diff --git a/src/tagmanager/tm_parser.h b/src/tagmanager/tm_parser.h index 38a86af89..b845b5c54 100644 --- a/src/tagmanager/tm_parser.h +++ b/src/tagmanager/tm_parser.h @@ -54,7 +54,7 @@ typedef gint TMParserType; #ifdef GEANY_PRIVATE -/* keep in sync with ctags/parsers.h */ +/* keep in sync with tm_parsers.h and parser_map in tm_parser.c */ enum { TM_PARSER_NONE = -2, /* keep in sync with ctags LANG_IGNORE */ diff --git a/src/tagmanager/tm_parsers.h b/src/tagmanager/tm_parsers.h new file mode 100644 index 000000000..0b782082f --- /dev/null +++ b/src/tagmanager/tm_parsers.h @@ -0,0 +1,70 @@ +/* +* Copyright (c) 2019, Jiri Techet +* +* This source code is released for free distribution under the terms of the +* GNU General Public License version 2 or (at your option) any later version. +* +* Declares parsers used by ctags +*/ +#ifndef TM_PARSERS_H +#define TM_PARSERS_H + +/* This file is included by ctags by defining EXTERNAL_PARSER_LIST_FILE inside + * ctags/Makefile.am */ + +/* Keep in sync with tm_parser.h */ +#define EXTERNAL_PARSER_LIST \ + CParser, \ + CppParser, \ + JavaParser, \ + MakefileParser, \ + PascalParser, \ + PerlParser, \ + PhpParser, \ + PythonParser, \ + TexParser, \ + AsmParser, \ + ConfParser, \ + SqlParser, \ + DocBookParser, \ + ErlangParser, \ + CssParser, \ + RubyParser, \ + TclParser, \ + ShParser, \ + DParser, \ + FortranParser, \ + FeriteParser, \ + DiffParser, \ + VhdlParser, \ + LuaParser, \ + JavaScriptParser, \ + HaskellParser, \ + CsharpParser, \ + BasicParser,\ + HaxeParser,\ + RstParser, \ + HtmlParser, \ + F77Parser, \ + GLSLParser, \ + MatLabParser, \ + ValaParser, \ + FlexParser, \ + NsisParser, \ + MarkdownParser, \ + Txt2tagsParser, \ + AbcParser, \ + VerilogParser, \ + RParser, \ + CobolParser, \ + ObjcParser, \ + AsciidocParser, \ + AbaqusParser, \ + RustParser, \ + GoParser, \ + JsonParser, \ + ZephirParser, \ + PowerShellParser, \ + BibtexParser + +#endif diff --git a/src/tagmanager/tm_source_file.c b/src/tagmanager/tm_source_file.c index b76b81e21..b1f37f3b4 100644 --- a/src/tagmanager/tm_source_file.c +++ b/src/tagmanager/tm_source_file.c @@ -32,7 +32,7 @@ #include "tm_source_file.h" #include "tm_tag.h" #include "tm_parser.h" -#include "ctags-api.h" +#include "tm_ctags.h" typedef struct { @@ -136,7 +136,7 @@ gchar *tm_get_real_path(const gchar *file_name) return NULL; } -static char get_tag_impl(const char *impl) +gchar tm_source_file_get_tag_impl(const gchar *impl) { if ((0 == strcmp("virtual", impl)) || (0 == strcmp("pure virtual", impl))) @@ -148,7 +148,7 @@ static char get_tag_impl(const char *impl) return TAG_IMPL_UNKNOWN; } -static char get_tag_access(const char *access) +gchar tm_source_file_get_tag_access(const gchar *access) { if (0 == strcmp("public", access)) return TAG_ACCESS_PUBLIC; @@ -168,59 +168,6 @@ static char get_tag_access(const char *access) } /* - Initializes a TMTag structure with information from a ctagsTag struct - used by the ctags parsers. Note that the TMTag structure must be malloc()ed - before calling this function. - @param tag The TMTag structure to initialize - @param file Pointer to a TMSourceFile struct (it is assigned to the file member) - @param tag_entry Tag information gathered by the ctags parser - @return TRUE on success, FALSE on failure -*/ -static gboolean init_tag(TMTag *tag, TMSourceFile *file, const ctagsTag *tag_entry) -{ - TMTagType type; - - if (!tag_entry) - return FALSE; - - type = tm_parser_get_tag_type(tag_entry->kindLetter, tag_entry->lang); - if (file->lang != tag_entry->lang) /* this is a tag from a subparser */ - { - /* check for possible re-definition of subparser type */ - type = tm_parser_get_subparser_type(file->lang, tag_entry->lang, type); - } - - if (!tag_entry->name || type == tm_tag_undef_t) - return FALSE; - - tag->name = g_strdup(tag_entry->name); - tag->type = type; - tag->local = tag_entry->isFileScope; - tag->pointerOrder = 0; /* backward compatibility (use var_type instead) */ - tag->line = tag_entry->lineNumber; - if (NULL != tag_entry->signature) - tag->arglist = g_strdup(tag_entry->signature); - if ((NULL != tag_entry->scopeName) && - (0 != tag_entry->scopeName[0])) - tag->scope = g_strdup(tag_entry->scopeName); - if (tag_entry->inheritance != NULL) - tag->inheritance = g_strdup(tag_entry->inheritance); - if (tag_entry->varType != NULL) - tag->var_type = g_strdup(tag_entry->varType); - if (tag_entry->access != NULL) - tag->access = get_tag_access(tag_entry->access); - if (tag_entry->implementation != NULL) - tag->impl = get_tag_impl(tag_entry->implementation); - if ((tm_tag_macro_t == tag->type) && (NULL != tag->arglist)) - tag->type = tm_tag_macro_with_arg_t; - tag->file = file; - /* redefine lang also for subparsers because the rest of Geany assumes that - * tags from a single file are from a single language */ - tag->lang = file->lang; - return TRUE; -} - -/* Initializes an already malloc()ed TMTag structure by reading a tag entry line from a file. The structure should be allocated beforehand. @param tag The TMTag structure to populate @@ -429,7 +376,7 @@ static gboolean init_tag_from_file_ctags(TMTag *tag, TMSourceFile *file, FILE *f const gchar *kind = value ? value : key; if (kind[0] && kind[1]) - tag->type = tm_parser_get_tag_type(ctagsGetKindFromName(kind, lang), lang); + tag->type = tm_parser_get_tag_type(tm_ctags_get_kind_from_name(kind, lang), lang); else tag->type = tm_parser_get_tag_type(*kind, lang); } @@ -439,11 +386,11 @@ static gboolean init_tag_from_file_ctags(TMTag *tag, TMSourceFile *file, FILE *f tag->inheritance = g_strdup(value); } else if (0 == strcmp(key, "implementation")) /* implementation limit */ - tag->impl = get_tag_impl(value); + tag->impl = tm_source_file_get_tag_impl(value); else if (0 == strcmp(key, "line")) /* line */ tag->line = atol(value); else if (0 == strcmp(key, "access")) /* access */ - tag->access = get_tag_access(value); + tag->access = tm_source_file_get_tag_access(value); else if (0 == strcmp(key, "class") || 0 == strcmp(key, "enum") || 0 == strcmp(key, "function") || @@ -614,64 +561,6 @@ gboolean tm_source_file_write_tags_file(const gchar *tags_file, GPtrArray *tags_ return ret; } -/* add argument list of __init__() Python methods to the class tag */ -static void update_python_arglist(const TMTag *tag, TMSourceFile *current_source_file) -{ - guint i; - const char *parent_tag_name; - - if (tag->type != tm_tag_method_t || tag->scope == NULL || - g_strcmp0(tag->name, "__init__") != 0) - return; - - parent_tag_name = strrchr(tag->scope, '.'); - if (parent_tag_name) - parent_tag_name++; - else - parent_tag_name = tag->scope; - - /* going in reverse order because the tag was added recently */ - for (i = current_source_file->tags_array->len; i > 0; i--) - { - TMTag *prev_tag = (TMTag *) current_source_file->tags_array->pdata[i - 1]; - if (g_strcmp0(prev_tag->name, parent_tag_name) == 0) - { - g_free(prev_tag->arglist); - prev_tag->arglist = g_strdup(tag->arglist); - break; - } - } -} - -/* new parsing pass ctags callback function */ -static bool ctags_pass_start(void *user_data) -{ - TMSourceFile *current_source_file = user_data; - - tm_tags_array_free(current_source_file->tags_array, FALSE); - return TRUE; -} - -/* new tag ctags callback function */ -static bool ctags_new_tag(const ctagsTag *const tag, - void *user_data) -{ - TMSourceFile *current_source_file = user_data; - TMTag *tm_tag = tm_tag_new(); - - if (!init_tag(tm_tag, current_source_file, tag)) - { - tm_tag_unref(tm_tag); - return TRUE; - } - - if (tm_tag->lang == TM_PARSER_PYTHON) - update_python_arglist(tm_tag, current_source_file); - - g_ptr_array_add(current_source_file->tags_array, tm_tag); - - return TRUE; -} /* Initializes a TMSourceFile structure from a file name. */ static gboolean tm_source_file_init(TMSourceFile *source_file, const char *file_name, @@ -710,7 +599,7 @@ static gboolean tm_source_file_init(TMSourceFile *source_file, const char *file_ if (name == NULL) source_file->lang = TM_PARSER_NONE; else - source_file->lang = ctagsGetNamedLang(name); + source_file->lang = tm_ctags_get_named_lang(name); return TRUE; } @@ -827,8 +716,8 @@ gboolean tm_source_file_parse(TMSourceFile *source_file, guchar* text_buf, gsize tm_tags_array_free(source_file->tags_array, FALSE); - ctagsParse(use_buffer ? text_buf : NULL, buf_size, file_name, - source_file->lang, ctags_new_tag, ctags_pass_start, source_file); + tm_ctags_parse(use_buffer ? text_buf : NULL, buf_size, file_name, + source_file->lang, source_file); return !retry; } @@ -839,7 +728,7 @@ gboolean tm_source_file_parse(TMSourceFile *source_file, guchar* text_buf, gsize */ const gchar *tm_source_file_get_lang_name(TMParserType lang) { - return ctagsGetLangName(lang); + return tm_ctags_get_lang_name(lang); } /* Gets the language index for \a name. @@ -848,5 +737,5 @@ const gchar *tm_source_file_get_lang_name(TMParserType lang) */ TMParserType tm_source_file_get_named_lang(const gchar *name) { - return ctagsGetNamedLang(name); + return tm_ctags_get_named_lang(name); } diff --git a/src/tagmanager/tm_source_file.h b/src/tagmanager/tm_source_file.h index c4cc3627d..073048c41 100644 --- a/src/tagmanager/tm_source_file.h +++ b/src/tagmanager/tm_source_file.h @@ -62,6 +62,10 @@ GPtrArray *tm_source_file_read_tags_file(const gchar *tags_file, TMParserType mo gboolean tm_source_file_write_tags_file(const gchar *tags_file, GPtrArray *tags_array); +gchar tm_source_file_get_tag_impl(const gchar *impl); + +gchar tm_source_file_get_tag_access(const gchar *access); + #endif /* GEANY_PRIVATE */ G_END_DECLS diff --git a/src/tagmanager/tm_tag.c b/src/tagmanager/tm_tag.c index 37121a136..b16f3bcf9 100644 --- a/src/tagmanager/tm_tag.c +++ b/src/tagmanager/tm_tag.c @@ -13,7 +13,7 @@ #include #include "tm_tag.h" -#include "ctags-api.h" +#include "tm_ctags.h" #define TAG_NEW(T) ((T) = g_slice_new0(TMTag)) diff --git a/src/tagmanager/tm_workspace.c b/src/tagmanager/tm_workspace.c index 3cfbc1b5c..6c5aa7474 100644 --- a/src/tagmanager/tm_workspace.c +++ b/src/tagmanager/tm_workspace.c @@ -17,8 +17,6 @@ and a set of individual source files. */ -#include "general.h" - #include #include #include @@ -32,7 +30,7 @@ #include #include "tm_workspace.h" -#include "ctags-api.h" +#include "tm_ctags.h" #include "tm_tag.h" #include "tm_parser.h" @@ -79,7 +77,7 @@ static gboolean tm_create_workspace(void) theWorkspace->typename_array = g_ptr_array_new(); theWorkspace->global_typename_array = g_ptr_array_new(); - ctagsInit(); + tm_ctags_init(); tm_parser_verify_type_mappings(); return TRUE; @@ -664,7 +662,7 @@ static void fill_find_tags_array(GPtrArray *dst, const GPtrArray *src, @param scope The scope name of the tag to find, or NULL. @param type The tag types to return (TMTagType). Can be a bitmask. @param attrs The attributes to sort and dedup on (0 terminated integer array). - @param lang Specifies the language(see the table in parsers.h) of the tags to be found, + @param lang Specifies the language(see the table in tm_parsers.h) of the tags to be found, -1 for all @return Array of matching tags. */ @@ -712,7 +710,7 @@ static void fill_find_tags_array_prefix(GPtrArray *dst, const GPtrArray *src, /* Returns tags with the specified prefix sorted by name. If there are several tags with the same name, only one of them appears in the resulting array. @param prefix The prefix of the tag to find. - @param lang Specifies the language(see the table in parsers.h) of the tags to be found, + @param lang Specifies the language(see the table in tm_parsers.h) of the tags to be found, -1 for all. @param max_num The maximum number of tags to return. @return Array of matching tags sorted by their name. -- 2.11.4.GIT