[geany/geany] 8385b0: Merge pull request #3137 from techee/tree_mapping - Commits

10 Apr 2022


      Branch:      refs/heads/master
Author:      Enrico Tröger enrico.troeger@uvena.de
Committer:   GitHub noreply@github.com
Date:        Sun, 10 Apr 2022 19:28:53 UTC
Commit:      8385b048bf71f26100432028c7411968e5661826
             https://github.com/geany/geany/commit/8385b048bf71f26100432028c7411968e56618...
Log Message:
-----------
Merge pull request #3137 from techee/tree_mapping
Move symbol tree root mappings to tm_parser.c
Modified Paths:
--------------
    HACKING
    po/POTFILES.in
    src/editor.c
    src/keyfile.c
    src/symbols.c
    src/tagmanager/tm_ctags.c
    src/tagmanager/tm_parser.c
    src/tagmanager/tm_parser.h
Modified: HACKING
41 lines changed, 19 insertions(+), 22 deletions(-)
===================================================================
@@ -500,13 +500,13 @@ other changes should be passed on to the maintainers at
 http://scintilla.org. We normally update to a new Scintilla release
 shortly after one is made. See also scintilla/README.
-Tagmanager was originally taken from Anjuta 1.2.2, and parts of it
-(notably c.c) have been merged from later versions of Anjuta and
-CTags. The independent Tagmanager library itself ceased development
-before Geany was started. It's source code parsing is mostly taken from
-Exuberant CTags (see http://ctags.sf.net). If appropriate it's good to
-pass language parser changes back to the CTags project.
-
+We use an unmodified subset of universal-ctags sources
+(https://github.com/universal-ctags/ctags) to parse open documents. We
+also use the great majority of unmodified universal-ctags parsers except
+a few outliers that are maintained by us (those whose file names start
+with geany_). We normally update to the latest version of
+universal-ctags shortly after making a Geany release and keep this
+version during the rest of the development cycle.
Notes
 =====
@@ -650,18 +650,13 @@ indentation after ':' is done from on_new_line_added().
 If the Scintilla lexer supports user type keyword highlighting (e.g.
 SCLEX_CPP), update document_update_tags() in document.c.
-Adding a TagManager parser
-^^^^^^^^^^^^^^^^^^^^^^^^^^
+Adding a CTags parser
+^^^^^^^^^^^^^^^^^^^^^
 This assumes the filetype for Geany already exists.
First write or find a CTags compatible parser, foo.c. Check this fork:
 https://github.com/universal-ctags/ctags
-There may be some unmerged language patches for CTags at:
-http://sf.net/projects/ctags - see the tracker.
-
-(You can also try the Anjuta project's anjuta-tags codebase.)
-
 Method
 ``````
 * Add foo.c to SRCS in Makefile.am.
@@ -673,20 +668,22 @@ In src/tagmanager/tm_parser.c:
 Add a map_FOO TMParserMapEntry mapping each kind's letter from foo.c's
 FooKinds to the appropriate TMTagType, and add the corresponding
 MAP_ENTRY(FOO) to parser_map.
-(You may want to make the symbols.c change before doing this).
In src/tagmanager/tm_parser.c:
-Update tm_parser_scope_separator() and tm_parser_has_full_scope() to
-handle the new parser if applicable, by adding a TM_PARSER_FOO case entry.
+Add a group_FOO TMParserMapGroup defining root nodes of the symbol tree,
+used icons and TMTagType values grouped under the specified root.
+Multiple TMTagType values can be combined under a single root using |
+(bitwise OR).
+
+In src/tagmanager/tm_parser.c:
+Update various functions at the end of tm_parser.c to adjust Geany
+behavior to the behavior of the added parser. In particular, update
+tm_parser_scope_separator() and tm_parser_has_full_scope() so
+scope-related functionality works correctly.
In filetypes.c, init_builtin_filetypes():
 Set the 2nd argument of the FT_INIT() macro for this filetype to FOO.
-In symbols.c:
-Unless your parser uses C-like tag type kinds, update
-add_top_level_items() for foo, calling tag_list_add_groups(). See
-get_tag_type_iter() for which tv_iters fields to use.
-
 Tests
 `````
 The tag parser tests checks if the proper tags are emitted
Modified: po/POTFILES.in
1 lines changed, 1 insertions(+), 0 deletions(-)
===================================================================
@@ -40,6 +40,7 @@ src/ui_utils.c
 src/utils.c
 src/vte.c
 src/win32.c
+src/tagmanager/tm_parser.c
 plugins/classbuilder.c
 plugins/htmlchars.c
 plugins/export.c
Modified: src/editor.c
1 lines changed, 0 insertions(+), 1 deletions(-)
===================================================================
@@ -708,7 +708,6 @@ static gboolean autocomplete_scope(GeanyEditor *editor, const gchar *root, gsize
    gboolean scope_sep_typed = FALSE;
    gboolean ret = FALSE;
    const gchar *current_scope;
-	const gchar *context_sep = tm_parser_scope_separator(ft->lang);
    gint autocomplete_suffix_len;
if (autocomplete_scope_shown)
Modified: src/keyfile.c
3 lines changed, 0 insertions(+), 3 deletions(-)
===================================================================
@@ -1458,9 +1458,6 @@ void configuration_init(void)
void configuration_finalize(void)
 {
-	guint i;
-	StashGroup *group;
-
    g_signal_handlers_disconnect_by_func(geany_object, G_CALLBACK(document_list_changed_cb), NULL);
g_ptr_array_free(pref_groups, TRUE);
Modified: src/symbols.c
630 lines changed, 46 insertions(+), 584 deletions(-)
===================================================================
@@ -73,34 +73,22 @@ typedef struct
static GPtrArray *top_level_iter_names = NULL;
-enum
-{
-	ICON_CLASS,
-	ICON_MACRO,
-	ICON_MEMBER,
-	ICON_METHOD,
-	ICON_NAMESPACE,
-	ICON_OTHER,
-	ICON_STRUCT,
-	ICON_VAR,
-	ICON_NONE,
-	N_ICONS = ICON_NONE
-};
static struct
 {
    const gchar *icon_name;
    GdkPixbuf *pixbuf;
 }
-symbols_icons[N_ICONS] = {
-	[ICON_CLASS]		= { "classviewer-class", NULL },
-	[ICON_MACRO]		= { "classviewer-macro", NULL },
-	[ICON_MEMBER]		= { "classviewer-member", NULL },
-	[ICON_METHOD]		= { "classviewer-method", NULL },
-	[ICON_NAMESPACE]	= { "classviewer-namespace", NULL },
-	[ICON_OTHER]		= { "classviewer-other", NULL },
-	[ICON_STRUCT]		= { "classviewer-struct", NULL },
-	[ICON_VAR]			= { "classviewer-var", NULL },
+/* keep in sync with enum in tm_parser.h */
+symbols_icons[TM_N_ICONS] = {
+	[TM_ICON_CLASS]		= { "classviewer-class", NULL },
+	[TM_ICON_MACRO]		= { "classviewer-macro", NULL },
+	[TM_ICON_MEMBER]	= { "classviewer-member", NULL },
+	[TM_ICON_METHOD]	= { "classviewer-method", NULL },
+	[TM_ICON_NAMESPACE]	= { "classviewer-namespace", NULL },
+	[TM_ICON_OTHER]		= { "classviewer-other", NULL },
+	[TM_ICON_STRUCT]	= { "classviewer-struct", NULL },
+	[TM_ICON_VAR]		= { "classviewer-var", NULL },
 };
static struct
@@ -319,7 +307,7 @@ static gint compare_symbol_lines(gconstpointer a, gconstpointer b)
 static GList *get_tag_list(GeanyDocument *doc, TMTagType tag_types)
 {
    GList *tag_names = NULL;
-	guint i, j;
+	guint i;
    gchar **tf_strv;
g_return_val_if_fail(doc, NULL);
@@ -375,40 +363,19 @@ static GList *get_tag_list(GeanyDocument *doc, TMTagType tag_types)
 }
-/* amount of types in the symbol list (currently max. 8 are used) */
-#define MAX_SYMBOL_TYPES	(sizeof(tv_iters) / sizeof(GtkTreeIter))
+/* amount of types in the symbol list - can be increased if needed */
+#define MAX_SYMBOL_TYPES 15
-struct TreeviewSymbols
-{
-	GtkTreeIter		 tag_function;
-	GtkTreeIter		 tag_class;
-	GtkTreeIter		 tag_macro;
-	GtkTreeIter		 tag_member;
-	GtkTreeIter		 tag_variable;
-	GtkTreeIter		 tag_externvar;
-	GtkTreeIter		 tag_namespace;
-	GtkTreeIter		 tag_struct;
-	GtkTreeIter		 tag_interface;
-	GtkTreeIter		 tag_type;
-	GtkTreeIter		 tag_other;
-} tv_iters;
+GtkTreeIter tv_iters[MAX_SYMBOL_TYPES];
static void init_tag_iters(void)
 {
+	guint i;
    /* init all GtkTreeIters with -1 to make them invalid to avoid crashes when switching between
     * filetypes(e.g. config file to Python crashes Geany without this) */
-	tv_iters.tag_function.stamp = -1;
-	tv_iters.tag_class.stamp = -1;
-	tv_iters.tag_member.stamp = -1;
-	tv_iters.tag_macro.stamp = -1;
-	tv_iters.tag_variable.stamp = -1;
-	tv_iters.tag_externvar.stamp = -1;
-	tv_iters.tag_namespace.stamp = -1;
-	tv_iters.tag_struct.stamp = -1;
-	tv_iters.tag_interface.stamp = -1;
-	tv_iters.tag_type.stamp = -1;
-	tv_iters.tag_other.stamp = -1;
+	for (i = 0; i < MAX_SYMBOL_TYPES; i++)
+		tv_iters[i].stamp = -1;
 }
@@ -454,28 +421,24 @@ static gboolean find_toplevel_iter(GtkTreeStore *store, GtkTreeIter *iter, const
 }
-/* Adds symbol list groups in (iter*, title) pairs.
- * The list must be ended with NULL. */
-static void G_GNUC_NULL_TERMINATED
-tag_list_add_groups(GtkTreeStore *tree_store, ...)
+static void tag_list_add_groups(GtkTreeStore *tree_store, TMParserType lang)
 {
-	va_list args;
-	GtkTreeIter *iter;
+	const gchar *title;
+	guint i;
+	guint icon_id;
g_return_if_fail(top_level_iter_names);
-	va_start(args, tree_store);
-	for (; iter = va_arg(args, GtkTreeIter*), iter != NULL;)
+	for (i = 0; title = tm_parser_get_sidebar_info(lang, i, &icon_id); i++)
    {
-		gchar *title = va_arg(args, gchar*);
-		guint icon_id = va_arg(args, guint);
+		GtkTreeIter *iter = &tv_iters[i];
    	GdkPixbuf *icon = NULL;
-		if (icon_id < N_ICONS)
+		if (icon_id < TM_N_ICONS)
    		icon = symbols_icons[icon_id].pixbuf;
g_assert(title != NULL);
-		g_ptr_array_add(top_level_iter_names, title);
+		g_ptr_array_add(top_level_iter_names, (gchar *)title);
if (!find_toplevel_iter(tree_store, iter, title))
    		gtk_tree_store_append(tree_store, iter, NULL);
@@ -484,13 +447,12 @@ tag_list_add_groups(GtkTreeStore *tree_store, ...)
    		gtk_tree_store_set(tree_store, iter, SYMBOLS_COLUMN_ICON, icon, -1);
    	gtk_tree_store_set(tree_store, iter, SYMBOLS_COLUMN_NAME, title, -1);
    }
-	va_end(args);
 }
static void add_top_level_items(GeanyDocument *doc)
 {
-	GeanyFiletypeID ft_id = doc->file_type->id;
+	TMParserType lang = doc->file_type->lang;
    GtkTreeStore *tag_store = doc->priv->tag_store;
if (top_level_iter_names == NULL)
@@ -500,422 +462,7 @@ static void add_top_level_items(GeanyDocument *doc)
init_tag_iters();
-	switch (ft_id)
-	{
-		case GEANY_FILETYPES_DIFF:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_function), _("Files"), ICON_NONE, NULL);
-			break;
-		}
-		case GEANY_FILETYPES_DOCBOOK:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_function), _("Chapter"), ICON_NONE,
-				&(tv_iters.tag_class), _("Section"), ICON_NONE,
-				&(tv_iters.tag_member), _("Sect1"), ICON_NONE,
-				&(tv_iters.tag_macro), _("Sect2"), ICON_NONE,
-				&(tv_iters.tag_variable), _("Sect3"), ICON_NONE,
-				&(tv_iters.tag_struct), _("Appendix"), ICON_NONE,
-				&(tv_iters.tag_other), _("Other"), ICON_NONE,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_HASKELL:
-			tag_list_add_groups(tag_store,
-				&tv_iters.tag_namespace, _("Module"), ICON_NONE,
-				&tv_iters.tag_type, _("Types"), ICON_NONE,
-				&tv_iters.tag_macro, _("Type constructors"), ICON_NONE,
-				&tv_iters.tag_function, _("Functions"), ICON_METHOD,
-				NULL);
-			break;
-		case GEANY_FILETYPES_COBOL:
-			tag_list_add_groups(tag_store,
-				&tv_iters.tag_class, _("Program"), ICON_CLASS,
-				&tv_iters.tag_function, _("File"), ICON_METHOD,
-				&tv_iters.tag_interface, _("Divisions"), ICON_NAMESPACE,
-				&tv_iters.tag_namespace, _("Sections"), ICON_NAMESPACE,
-				&tv_iters.tag_macro, _("Paragraph"), ICON_OTHER,
-				&tv_iters.tag_struct, _("Group"), ICON_STRUCT,
-				&tv_iters.tag_variable, _("Data"), ICON_VAR,
-				&tv_iters.tag_externvar, _("Copies"), ICON_NAMESPACE,
-				NULL);
-			break;
-		case GEANY_FILETYPES_CONF:
-			tag_list_add_groups(tag_store,
-				&tv_iters.tag_namespace, _("Sections"), ICON_OTHER,
-				&tv_iters.tag_macro, _("Keys"), ICON_VAR,
-				NULL);
-			break;
-		case GEANY_FILETYPES_GDSCRIPT:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_member), _("Methods"), ICON_MACRO,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_externvar), _("Imports"), ICON_NAMESPACE,
-				&(tv_iters.tag_type), _("Enums"), ICON_STRUCT,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_NSIS:
-			tag_list_add_groups(tag_store,
-				&tv_iters.tag_namespace, _("Sections"), ICON_OTHER,
-				&tv_iters.tag_function, _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				NULL);
-			break;
-		case GEANY_FILETYPES_LATEX:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_function), _("Command"), ICON_NONE,
-				&(tv_iters.tag_class), _("Environment"), ICON_NONE,
-				&(tv_iters.tag_member), _("Section"), ICON_NONE,
-				&(tv_iters.tag_macro), _("Subsection"), ICON_NONE,
-				&(tv_iters.tag_variable), _("Subsubsection"), ICON_NONE,
-				&(tv_iters.tag_struct), _("Label"), ICON_NONE,
-				&(tv_iters.tag_namespace), _("Chapter"), ICON_NONE,
-				&(tv_iters.tag_other), _("Other"), ICON_NONE,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_BIBTEX:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_function), _("Articles"), ICON_NONE,
-				&(tv_iters.tag_macro), _("Book Chapters"), ICON_NONE,
-				&(tv_iters.tag_class), _("Books & Conference Proceedings"), ICON_NONE,
-				&(tv_iters.tag_member), _("Conference Papers"), ICON_NONE,
-				&(tv_iters.tag_variable), _("Theses"), ICON_NONE,
-				&(tv_iters.tag_namespace), _("Strings"), ICON_NONE,
-				&(tv_iters.tag_externvar), _("Unpublished"), ICON_NONE,
-				&(tv_iters.tag_other), _("Other"), ICON_NONE,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_MATLAB:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_struct), _("Structures"), ICON_STRUCT,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_ABAQUS:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_class), _("Parts"), ICON_NONE,
-				&(tv_iters.tag_member), _("Assembly"), ICON_NONE,
-				&(tv_iters.tag_namespace), _("Steps"), ICON_NONE,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_R:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_other), _("Other"), ICON_NONE,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_RUST:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Modules"), ICON_NAMESPACE,
-				&(tv_iters.tag_struct), _("Structures"), ICON_STRUCT,
-				&(tv_iters.tag_interface), _("Traits"), ICON_CLASS,
-				&(tv_iters.tag_class), _("Implementations"), ICON_CLASS,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_type), _("Typedefs / Enums"), ICON_STRUCT,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_macro), _("Macros"), ICON_MACRO,
-				&(tv_iters.tag_member), _("Methods"), ICON_MEMBER,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_GO:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Package"), ICON_NAMESPACE,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_interface), _("Interfaces"), ICON_STRUCT,
-				&(tv_iters.tag_struct), _("Structs"), ICON_STRUCT,
-				&(tv_iters.tag_type), _("Types"), ICON_STRUCT,
-				&(tv_iters.tag_macro), _("Constants"), ICON_MACRO,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_member), _("Members"), ICON_MEMBER,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_PERL:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Package"), ICON_NAMESPACE,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_macro), _("Labels"), ICON_NONE,
-				&(tv_iters.tag_type), _("Constants"), ICON_NONE,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_PHP:
-		case GEANY_FILETYPES_ZEPHIR:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Namespaces"), ICON_NAMESPACE,
-				&(tv_iters.tag_interface), _("Interfaces"), ICON_STRUCT,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_macro), _("Constants"), ICON_MACRO,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_struct), _("Traits"), ICON_STRUCT,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_JULIA:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_variable), _("Constants"), ICON_VAR,
-				&(tv_iters.tag_namespace), _("Modules"), ICON_NAMESPACE,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_member), _("Fields"), ICON_MEMBER,
-				&(tv_iters.tag_macro), _("Macros"), ICON_MACRO,
-				&(tv_iters.tag_struct), _("Structures"), ICON_STRUCT,
-				&(tv_iters.tag_type), _("Types"), ICON_CLASS,
-				&(tv_iters.tag_externvar), _("Unknowns"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_HTML:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_function), _("Functions"), ICON_NONE,
-				&(tv_iters.tag_member), _("Anchors"), ICON_NONE,
-				&(tv_iters.tag_namespace), _("H1 Headings"), ICON_NONE,
-				&(tv_iters.tag_class), _("H2 Headings"), ICON_NONE,
-				&(tv_iters.tag_variable), _("H3 Headings"), ICON_NONE,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_CSS:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_variable), _("ID Selectors"), ICON_VAR,
-				&(tv_iters.tag_struct), _("Type Selectors"), ICON_STRUCT, NULL);
-			break;
-		}
-		case GEANY_FILETYPES_REST:
-		case GEANY_FILETYPES_TXT2TAGS:
-		case GEANY_FILETYPES_ABC:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Chapter"), ICON_NONE,
-				&(tv_iters.tag_member), _("Section"), ICON_NONE,
-				&(tv_iters.tag_macro), _("Subsection"), ICON_NONE,
-				&(tv_iters.tag_variable), _("Subsubsection"), ICON_NONE,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_ASCIIDOC:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Document"), ICON_NONE,
-				&(tv_iters.tag_member), _("Section Level 1"), ICON_NONE,
-				&(tv_iters.tag_macro), _("Section Level 2"), ICON_NONE,
-				&(tv_iters.tag_variable), _("Section Level 3"), ICON_NONE,
-				&(tv_iters.tag_struct), _("Section Level 4"), ICON_NONE,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_RUBY:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Modules"), ICON_NAMESPACE,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_member), _("Singletons"), ICON_STRUCT,
-				&(tv_iters.tag_function), _("Methods"), ICON_METHOD,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_TCL:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Namespaces"), ICON_NAMESPACE,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_member), _("Methods"), ICON_METHOD,
-				&(tv_iters.tag_function), _("Procedures"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_PYTHON:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_member), _("Methods"), ICON_MACRO,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_externvar), _("Imports"), ICON_NAMESPACE,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_VHDL:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Package"), ICON_NAMESPACE,
-				&(tv_iters.tag_class), _("Entities"), ICON_CLASS,
-				&(tv_iters.tag_struct), _("Architectures"), ICON_STRUCT,
-				&(tv_iters.tag_type), _("Types"), ICON_OTHER,
-				&(tv_iters.tag_function), _("Functions / Procedures"), ICON_METHOD,
-				&(tv_iters.tag_variable), _("Variables / Signals"), ICON_VAR,
-				&(tv_iters.tag_member), _("Processes / Blocks / Components"), ICON_MEMBER,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_VERILOG:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_type), _("Events"), ICON_MACRO,
-				&(tv_iters.tag_class), _("Modules"), ICON_CLASS,
-				&(tv_iters.tag_function), _("Functions / Tasks"), ICON_METHOD,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_JAVA:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Package"), ICON_NAMESPACE,
-				&(tv_iters.tag_interface), _("Interfaces"), ICON_STRUCT,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_function), _("Methods"), ICON_METHOD,
-				&(tv_iters.tag_member), _("Members"), ICON_MEMBER,
-				&(tv_iters.tag_type), _("Enums"), ICON_STRUCT,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_AS:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_externvar), _("Imports"), ICON_NAMESPACE,
-				&(tv_iters.tag_namespace), _("Package"), ICON_NAMESPACE,
-				&(tv_iters.tag_interface), _("Interfaces"), ICON_STRUCT,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_member), _("Properties"), ICON_MEMBER,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_macro), _("Constants"), ICON_MACRO,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_HAXE:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_interface), _("Interfaces"), ICON_STRUCT,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_function), _("Methods"), ICON_METHOD,
-				&(tv_iters.tag_type), _("Types"), ICON_MACRO,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_BASIC:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_macro), _("Constants"), ICON_MACRO,
-				&(tv_iters.tag_struct), _("Types"), ICON_NAMESPACE,
-				&(tv_iters.tag_namespace), _("Labels"), ICON_MEMBER,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_F77:
-		case GEANY_FILETYPES_FORTRAN:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Module"), ICON_CLASS,
-				&(tv_iters.tag_struct), _("Programs"), ICON_CLASS,
-				&(tv_iters.tag_interface), _("Interfaces"), ICON_STRUCT,
-				&(tv_iters.tag_function), _("Functions / Subroutines"), ICON_METHOD,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_class), _("Types"), ICON_CLASS,
-				&(tv_iters.tag_member), _("Components"), ICON_MEMBER,
-				&(tv_iters.tag_macro), _("Blocks"), ICON_MEMBER,
-				&(tv_iters.tag_type), _("Enums"), ICON_STRUCT,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_ASM:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_namespace), _("Labels"), ICON_NAMESPACE,
-				&(tv_iters.tag_function), _("Macros"), ICON_METHOD,
-				&(tv_iters.tag_macro), _("Defines"), ICON_MACRO,
-				&(tv_iters.tag_struct), _("Types"), ICON_STRUCT,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_MAKE:
-			tag_list_add_groups(tag_store,
-				&tv_iters.tag_function, _("Targets"), ICON_METHOD,
-				&tv_iters.tag_macro, _("Macros"), ICON_MACRO,
-				NULL);
-			break;
-		case GEANY_FILETYPES_SQL:
-		{
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_namespace), _("Procedures"), ICON_NAMESPACE,
-				&(tv_iters.tag_struct), _("Indexes"), ICON_STRUCT,
-				&(tv_iters.tag_class), _("Tables"), ICON_CLASS,
-				&(tv_iters.tag_macro), _("Triggers"), ICON_MACRO,
-				&(tv_iters.tag_member), _("Views"), ICON_VAR,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				NULL);
-			break;
-		}
-		case GEANY_FILETYPES_D:
-		default:
-		{
-			if (ft_id == GEANY_FILETYPES_D)
-				tag_list_add_groups(tag_store,
-					&(tv_iters.tag_namespace), _("Module"), ICON_NONE, NULL);
-			else
-				tag_list_add_groups(tag_store,
-					&(tv_iters.tag_namespace), _("Namespaces"), ICON_NAMESPACE, NULL);
-
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_class), _("Classes"), ICON_CLASS,
-				&(tv_iters.tag_interface), _("Interfaces"), ICON_STRUCT,
-				&(tv_iters.tag_function), _("Functions"), ICON_METHOD,
-				&(tv_iters.tag_member), _("Members"), ICON_MEMBER,
-				&(tv_iters.tag_struct), _("Structs"), ICON_STRUCT,
-				&(tv_iters.tag_type), _("Typedefs / Enums"), ICON_STRUCT,
-				NULL);
-
-			if (ft_id != GEANY_FILETYPES_D)
-			{
-				tag_list_add_groups(tag_store,
-					&(tv_iters.tag_macro), _("Macros"), ICON_MACRO, NULL);
-			}
-			tag_list_add_groups(tag_store,
-				&(tv_iters.tag_variable), _("Variables"), ICON_VAR,
-				&(tv_iters.tag_externvar), _("Extern Variables"), ICON_VAR,
-				&(tv_iters.tag_other), _("Other"), ICON_OTHER, NULL);
-		}
-	}
+	tag_list_add_groups(tag_store, lang);
 }
@@ -1019,87 +566,24 @@ static const gchar *get_parent_name(const TMTag *tag)
 }
-static GtkTreeIter *get_tag_type_iter(TMTagType tag_type)
+static GtkTreeIter *get_tag_type_iter(TMParserType lang, TMTagType tag_type)
 {
-	GtkTreeIter *iter = NULL;
+	/* TODO: tm_parser_get_sidebar_group() goes through groups one by one.
+	 * If this happens to be slow for tree construction, create a lookup
+	 * table for them. */
+	gint group = tm_parser_get_sidebar_group(lang, tag_type);
-	switch (tag_type)
-	{
-		case tm_tag_prototype_t:
-		case tm_tag_method_t:
-		case tm_tag_function_t:
-		{
-			iter = &tv_iters.tag_function;
-			break;
-		}
-		case tm_tag_externvar_t:
-		{
-			iter = &tv_iters.tag_externvar;
-			break;
-		}
-		case tm_tag_macro_t:
-		case tm_tag_macro_with_arg_t:
-		{
-			iter = &tv_iters.tag_macro;
-			break;
-		}
-		case tm_tag_class_t:
-		{
-			iter = &tv_iters.tag_class;
-			break;
-		}
-		case tm_tag_member_t:
-		case tm_tag_field_t:
-		{
-			iter = &tv_iters.tag_member;
-			break;
-		}
-		case tm_tag_typedef_t:
-		case tm_tag_enum_t:
-		{
-			iter = &tv_iters.tag_type;
-			break;
-		}
-		case tm_tag_union_t:
-		case tm_tag_struct_t:
-		{
-			iter = &tv_iters.tag_struct;
-			break;
-		}
-		case tm_tag_interface_t:
-			iter = &tv_iters.tag_interface;
-			break;
-		case tm_tag_variable_t:
-		{
-			iter = &tv_iters.tag_variable;
-			break;
-		}
-		case tm_tag_namespace_t:
-		case tm_tag_package_t:
-		{
-			iter = &tv_iters.tag_namespace;
-			break;
-		}
-		default:
-		{
-			iter = &tv_iters.tag_other;
-		}
-	}
-	if (G_LIKELY(iter->stamp != -1))
-		return iter;
-	else
+	if (group < 0)
    	return NULL;
+
+	return &tv_iters[group];
 }
static GdkPixbuf *get_child_icon(GtkTreeStore *tree_store, GtkTreeIter *parent)
 {
    GdkPixbuf *icon = NULL;
-	if (parent == &tv_iters.tag_other)
-	{
-		return g_object_ref(symbols_icons[ICON_VAR].pixbuf);
-	}
    /* copy parent icon */
    gtk_tree_model_get(GTK_TREE_MODEL(tree_store), parent,
    	SYMBOLS_COLUMN_ICON, &icon, -1);
@@ -1493,10 +977,8 @@ static void update_tree_tags(GeanyDocument *doc, GList **tags)
    	TMTag *tag = item->data;
    	GtkTreeIter *parent;
-		parent = get_tag_type_iter(tag->type);
-		if (G_UNLIKELY(! parent))
-			geany_debug("Missing symbol-tree parent iter for type %d!", tag->type);
-		else
+		parent = get_tag_type_iter(tag->lang, tag->type);
+		if (parent)
    	{
    		gboolean expand;
    		const gchar *name;
@@ -1899,38 +1381,18 @@ static void on_goto_popup_item_activate(GtkMenuItem *item, TMTag *tag)
 }
-/* FIXME: use the same icons as in the symbols tree defined in add_top_level_items() */
 static guint get_tag_class(const TMTag *tag)
 {
-	switch (tag->type)
-	{
-		case tm_tag_prototype_t:
-		case tm_tag_method_t:
-		case tm_tag_function_t:
-			return ICON_METHOD;
-		case tm_tag_variable_t:
-		case tm_tag_externvar_t:
-			return ICON_VAR;
-		case tm_tag_macro_t:
-		case tm_tag_macro_with_arg_t:
-			return ICON_MACRO;
-		case tm_tag_class_t:
-			return ICON_CLASS;
-		case tm_tag_member_t:
-		case tm_tag_field_t:
-			return ICON_MEMBER;
-		case tm_tag_typedef_t:
-		case tm_tag_enum_t:
-		case tm_tag_union_t:
-		case tm_tag_struct_t:
-			return ICON_STRUCT;
-		case tm_tag_namespace_t:
-		case tm_tag_package_t:
-			return ICON_NAMESPACE;
-		default:
-			break;
+	gint group = tm_parser_get_sidebar_group(tag->lang, tag->type);
+
+	if (group >= 0)
+	{
+		guint icon_id;
+		if (tm_parser_get_sidebar_info(tag->lang, group, &icon_id))
+			return icon_id;
    }
-	return ICON_STRUCT;
+
+	return TM_ICON_STRUCT;
 }
Modified: src/tagmanager/tm_ctags.c
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -69,7 +69,7 @@ static void enable_kinds_and_roles()
 {
    TMParserType lang;
-	for (lang = 0; lang < countParsers(); lang++)
+	for (lang = 0; lang < (gint)countParsers(); lang++)
    {
    	guint kind_num = countLanguageKinds(lang);
    	guint kind;
Modified: src/tagmanager/tm_parser.c
1138 lines changed, 754 insertions(+), 384 deletions(-)
===================================================================
@@ -23,6 +23,12 @@
#include <string.h>
+#include "config.h"
+
+
+/* Only for the command-line xgettext tool to find translatable strings.
+ * The gettext() function is invoked manually using glib g_dgettext() */
+#define _(String) (String)
typedef struct
 {
@@ -41,111 +47,162 @@ typedef struct
     TMTagType new_type;
 } TMSubparserMapEntry;
+typedef struct
+{
+    const gchar *name;
+    guint icon;
+    TMTagType  types;
+} TMParserMapGroup;
static GHashTable *subparser_map = NULL;
-#define COMMON_C \
-	{'d', tm_tag_macro_t}, \
-	{'e', tm_tag_enumerator_t}, \
-	{'f', tm_tag_function_t}, \
-	{'g', tm_tag_enum_t}, \
-	{'m', tm_tag_member_t}, \
-	{'p', tm_tag_prototype_t}, \
-	{'s', tm_tag_struct_t}, \
-	{'t', tm_tag_typedef_t}, \
-	{'u', tm_tag_union_t}, \
-	{'v', tm_tag_variable_t}, \
-	{'x', tm_tag_externvar_t},
-
-/* Old C parser, also used by GLSL and Ferite */
-static TMParserMapEntry map_C_old_parser[] = {
-	COMMON_C
-	{'c', tm_tag_class_t},
-	{'n', tm_tag_namespace_t},
-};
-# define COMMON_C_NEW_PARSER \
-	{'h', tm_tag_undef_t}, \
-	{'l', tm_tag_undef_t}, \
-	{'z', tm_tag_undef_t}, \
-	{'L', tm_tag_undef_t}, \
-	{'D', tm_tag_undef_t},
+#define COMMON_C \
+	{'d', tm_tag_macro_t},       /* macro */      \
+	{'e', tm_tag_enumerator_t},  /* enumerator */ \
+	{'f', tm_tag_function_t},    /* function */   \
+	{'g', tm_tag_enum_t},        /* enum */       \
+	{'m', tm_tag_member_t},      /* member */     \
+	{'p', tm_tag_prototype_t},   /* prototype */  \
+	{'s', tm_tag_struct_t},      /* struct */     \
+	{'t', tm_tag_typedef_t},     /* typedef */    \
+	{'u', tm_tag_union_t},       /* union */      \
+	{'v', tm_tag_variable_t},    /* variable */   \
+	{'x', tm_tag_externvar_t},   /* externvar */  \
+	{'h', tm_tag_undef_t},       /* header */     \
+	{'l', tm_tag_undef_t},       /* local */      \
+	{'z', tm_tag_undef_t},       /* parameter */  \
+	{'L', tm_tag_undef_t},       /* label */      \
+	{'D', tm_tag_undef_t},       /* macroparam */
static TMParserMapEntry map_C[] = {
    COMMON_C
-	COMMON_C_NEW_PARSER
+};
+/* Used also by other languages than C - keep all the tm_tag_* here even though
+ * they aren't used by C as they might be used by some other language */
+static TMParserMapGroup group_C[] = {
+	{_("Namespaces"), TM_ICON_NAMESPACE, tm_tag_namespace_t | tm_tag_package_t},
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_prototype_t | tm_tag_method_t | tm_tag_function_t},
+	{_("Members"), TM_ICON_MEMBER, tm_tag_member_t | tm_tag_field_t},
+	{_("Structs"), TM_ICON_STRUCT, tm_tag_union_t | tm_tag_struct_t},
+	{_("Typedefs / Enums"), TM_ICON_STRUCT, tm_tag_typedef_t | tm_tag_enum_t},
+	{_("Macros"), TM_ICON_MACRO, tm_tag_macro_t | tm_tag_macro_with_arg_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_enumerator_t},
+	{_("Extern Variables"), TM_ICON_VAR, tm_tag_externvar_t},
+	{_("Other"), TM_ICON_OTHER, tm_tag_other_t},
 };
static TMParserMapEntry map_CPP[] = {
    COMMON_C
-	COMMON_C_NEW_PARSER
-
-	{'c', tm_tag_class_t},
-	{'n', tm_tag_namespace_t},
-	{'A', tm_tag_undef_t},
-	{'N', tm_tag_undef_t},
-	{'U', tm_tag_undef_t},
-	{'Z', tm_tag_undef_t},
+	{'c', tm_tag_class_t},      // class
+	{'n', tm_tag_namespace_t},  // namespace
+	{'A', tm_tag_undef_t},      // alias
+	{'N', tm_tag_undef_t},      // name
+	{'U', tm_tag_undef_t},      // using
+	{'Z', tm_tag_undef_t},      // tparam
 };
+#define group_CPP group_C
static TMParserMapEntry map_JAVA[] = {
-	{'c', tm_tag_class_t},
-	{'f', tm_tag_field_t},
-	{'i', tm_tag_interface_t},
-	{'m', tm_tag_method_t},
-	{'p', tm_tag_package_t},
-	{'e', tm_tag_enumerator_t},
-	{'g', tm_tag_enum_t},
+	{'c', tm_tag_class_t},      // class
+	{'f', tm_tag_field_t},      // field
+	{'i', tm_tag_interface_t},  // interface
+	{'m', tm_tag_method_t},     // method
+	{'p', tm_tag_package_t},    // package
+	{'e', tm_tag_enumerator_t}, // enumConstant
+	{'g', tm_tag_enum_t},       // enum
+};
+static TMParserMapGroup group_JAVA[] = {
+	{_("Package"), TM_ICON_NAMESPACE, tm_tag_package_t},
+	{_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Methods"), TM_ICON_METHOD, tm_tag_method_t},
+	{_("Members"), TM_ICON_MEMBER, tm_tag_field_t},
+	{_("Enums"), TM_ICON_STRUCT, tm_tag_enum_t},
+	{_("Other"), TM_ICON_VAR, tm_tag_enumerator_t},
 };
+// no scope information
 static TMParserMapEntry map_MAKEFILE[] = {
-	{'m', tm_tag_macro_t},
-	{'t', tm_tag_function_t},
-	{'I', tm_tag_undef_t},
+	{'m', tm_tag_macro_t},     // macro
+	{'t', tm_tag_function_t},  // target
+	{'I', tm_tag_undef_t},     // makefile
+};
+static TMParserMapGroup group_MAKEFILE[] = {
+	{_("Targets"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
 };
static TMParserMapEntry map_PASCAL[] = {
-	{'f', tm_tag_function_t},
-	{'p', tm_tag_function_t},
+	{'f', tm_tag_function_t},  // function
+	{'p', tm_tag_function_t},  // procedure
+};
+static TMParserMapGroup group_PASCAL[] = {
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
 };
+// no scope information
 static TMParserMapEntry map_PERL[] = {
-	{'c', tm_tag_enum_t},
-	{'f', tm_tag_other_t},
-	{'l', tm_tag_macro_t},
-	{'p', tm_tag_package_t},
-	{'s', tm_tag_function_t},
-	{'d', tm_tag_prototype_t},
-	{'M', tm_tag_undef_t},
+	{'c', tm_tag_enum_t},       // constant
+	{'f', tm_tag_other_t},      // format
+	{'l', tm_tag_macro_t},      // label
+	{'p', tm_tag_package_t},    // package
+	{'s', tm_tag_function_t},   // subroutine
+	{'d', tm_tag_prototype_t},  // subroutineDeclaration
+	{'M', tm_tag_undef_t},      // module
+};
+static TMParserMapGroup group_PERL[] = {
+	{_("Package"), TM_ICON_NAMESPACE, tm_tag_package_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_prototype_t},
+	{_("Labels"), TM_ICON_NONE, tm_tag_macro_t},
+	{_("Constants"), TM_ICON_NONE, tm_tag_enum_t},
+	{_("Other"), TM_ICON_OTHER, tm_tag_other_t},
 };
static TMParserMapEntry map_PHP[] = {
-	{'c', tm_tag_class_t},
-	{'d', tm_tag_macro_t},
-	{'f', tm_tag_function_t},
-	{'i', tm_tag_interface_t},
-	{'l', tm_tag_undef_t},
-	{'n', tm_tag_namespace_t},
-	{'t', tm_tag_struct_t},
-	{'v', tm_tag_variable_t},
-	{'a', tm_tag_undef_t},
+	{'c', tm_tag_class_t},      // class
+	{'d', tm_tag_macro_t},      // define
+	{'f', tm_tag_function_t},   // function
+	{'i', tm_tag_interface_t},  // interface
+	{'l', tm_tag_undef_t},      // local
+	{'n', tm_tag_namespace_t},  // namespace
+	{'t', tm_tag_struct_t},     // trait
+	{'v', tm_tag_variable_t},   // variable
+	{'a', tm_tag_undef_t},      // alias
+};
+static TMParserMapGroup group_PHP[] = {
+	{_("Namespaces"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
+	{_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
+	{_("Traits"), TM_ICON_STRUCT, tm_tag_struct_t},
 };
static TMParserMapEntry map_PYTHON[] = {
-	{'c', tm_tag_class_t},
-	{'f', tm_tag_function_t},
-	{'m', tm_tag_method_t},
-	{'v', tm_tag_variable_t},
-	{'I', tm_tag_externvar_t},
-	{'i', tm_tag_externvar_t},
+	{'c', tm_tag_class_t},      // class
+	{'f', tm_tag_function_t},   // function
+	{'m', tm_tag_method_t},     // member
+	{'v', tm_tag_variable_t},   // variable
+	{'I', tm_tag_externvar_t},  // namespace
+	{'i', tm_tag_externvar_t},  // module
     /* defined as externvar to get those excluded as forward type in symbols.c:goto_tag()
      * so we can jump to the real implementation (if known) instead of to the import statement */
-	{'x', tm_tag_externvar_t},
-	{'z', tm_tag_undef_t},
-	{'l', tm_tag_undef_t},
+	{'x', tm_tag_externvar_t},  // unknown
+	{'z', tm_tag_undef_t},      // parameter
+	{'l', tm_tag_undef_t},      // local
+};
+static TMParserMapGroup group_PYTHON[] = {
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Methods"), TM_ICON_MACRO, tm_tag_method_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
+	{_("Imports"), TM_ICON_NAMESPACE, tm_tag_externvar_t},
 };
-/* different parser than tex.c from universal-ctags */
 static TMParserMapEntry map_LATEX[] = {
    {'f', tm_tag_function_t},
    {'c', tm_tag_class_t},
@@ -155,66 +212,104 @@ static TMParserMapEntry map_LATEX[] = {
    {'n', tm_tag_namespace_t},
    {'s', tm_tag_struct_t},
 };
+static TMParserMapGroup group_LATEX[] = {
+	{_("Command"), TM_ICON_NONE, tm_tag_function_t},
+	{_("Environment"), TM_ICON_NONE, tm_tag_class_t},
+	{_("Section"), TM_ICON_NONE, tm_tag_member_t},
+	{_("Subsection"), TM_ICON_NONE, tm_tag_macro_t},
+	{_("Subsubsection"), TM_ICON_NONE, tm_tag_variable_t},
+	{_("Label"), TM_ICON_NONE, tm_tag_struct_t},
+	{_("Chapter"), TM_ICON_NONE, tm_tag_namespace_t},
+};
+
+// no scope information
 static TMParserMapEntry map_BIBTEX[] = {
-	{'a', tm_tag_function_t},
-	{'b', tm_tag_class_t},
-	{'B', tm_tag_class_t},
-	{'c', tm_tag_member_t},
-	{'i', tm_tag_macro_t},
-	{'I', tm_tag_macro_t},
-	{'j', tm_tag_member_t},
-	{'m', tm_tag_other_t},
-	{'M', tm_tag_variable_t},
-	{'n', tm_tag_other_t},
-	{'p', tm_tag_variable_t},
-	{'P', tm_tag_class_t},
-	{'s', tm_tag_namespace_t},
-	{'t', tm_tag_other_t},
-	{'u', tm_tag_externvar_t},
+	{'a', tm_tag_function_t},   // article
+	{'b', tm_tag_class_t},      // book
+	{'B', tm_tag_class_t},      // booklet
+	{'c', tm_tag_member_t},     // conference
+	{'i', tm_tag_macro_t},      // inbook
+	{'I', tm_tag_macro_t},      // incollection
+	{'j', tm_tag_member_t},     // inproceedings
+	{'m', tm_tag_other_t},      // manual
+	{'M', tm_tag_variable_t},   // mastersthesis
+	{'n', tm_tag_other_t},      // misc
+	{'p', tm_tag_variable_t},   // phdthesis
+	{'P', tm_tag_class_t},      // proceedings
+	{'s', tm_tag_namespace_t},  // string
+	{'t', tm_tag_other_t},      // techreport
+	{'u', tm_tag_externvar_t},  // unpublished
+};
+static TMParserMapGroup group_BIBTEX[] = {
+	{_("Articles"), TM_ICON_NONE, tm_tag_function_t},
+	{_("Book Chapters"), TM_ICON_NONE, tm_tag_macro_t},
+	{_("Books & Conference Proceedings"), TM_ICON_NONE, tm_tag_class_t},
+	{_("Conference Papers"), TM_ICON_NONE, tm_tag_member_t},
+	{_("Theses"), TM_ICON_NONE, tm_tag_variable_t},
+	{_("Strings"), TM_ICON_NONE, tm_tag_namespace_t},
+	{_("Unpublished"), TM_ICON_NONE, tm_tag_externvar_t},
+	{_("Other"), TM_ICON_NONE, tm_tag_other_t},
 };
static TMParserMapEntry map_ASM[] = {
-	{'d', tm_tag_macro_t},
-	{'l', tm_tag_namespace_t},
-	{'m', tm_tag_function_t},
-	{'t', tm_tag_struct_t},
-	{'s', tm_tag_undef_t},
+	{'d', tm_tag_macro_t},      // define
+	{'l', tm_tag_namespace_t},  // label
+	{'m', tm_tag_function_t},   // macro
+	{'t', tm_tag_struct_t},     // type
+	{'s', tm_tag_undef_t},      // section
+};
+static TMParserMapGroup group_ASM[] = {
+	{_("Labels"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
+	{_("Macros"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Defines"), TM_ICON_MACRO, tm_tag_macro_t},
+	{_("Types"), TM_ICON_STRUCT, tm_tag_struct_t},
 };
-/* not in universal-ctags */
 static TMParserMapEntry map_CONF[] = {
-	{'s', tm_tag_namespace_t},
-	{'k', tm_tag_macro_t},
+	{'s', tm_tag_namespace_t},  // section
+	{'k', tm_tag_macro_t},      // key
+};
+static TMParserMapGroup group_CONF[] = {
+	{_("Sections"), TM_ICON_OTHER, tm_tag_namespace_t},
+	{_("Keys"), TM_ICON_VAR, tm_tag_macro_t},
 };
static TMParserMapEntry map_SQL[] = {
-	{'c', tm_tag_undef_t},
-	{'d', tm_tag_prototype_t},
-	{'f', tm_tag_function_t},
-	{'E', tm_tag_field_t},
-	{'l', tm_tag_undef_t},
-	{'L', tm_tag_undef_t},
-	{'P', tm_tag_package_t},
-	{'p', tm_tag_namespace_t},
-	{'r', tm_tag_undef_t},
-	{'s', tm_tag_undef_t},
-	{'t', tm_tag_class_t},
-	{'T', tm_tag_macro_t},
-	{'v', tm_tag_variable_t},
-	{'i', tm_tag_struct_t},
-	{'e', tm_tag_undef_t},
-	{'U', tm_tag_undef_t},
-	{'R', tm_tag_undef_t},
-	{'D', tm_tag_undef_t},
-	{'V', tm_tag_member_t},
-	{'n', tm_tag_undef_t},
-	{'x', tm_tag_undef_t},
-	{'y', tm_tag_undef_t},
-	{'z', tm_tag_undef_t},
-	{'C', tm_tag_undef_t},
-};
-
-/* not in universal-ctags */
+	{'c', tm_tag_undef_t},      // cursor
+	{'d', tm_tag_prototype_t},  // prototype
+	{'f', tm_tag_function_t},   // function
+	{'E', tm_tag_field_t},      // field
+	{'l', tm_tag_undef_t},      // local
+	{'L', tm_tag_undef_t},      // label
+	{'P', tm_tag_package_t},    // package
+	{'p', tm_tag_namespace_t},  // procedure
+	{'r', tm_tag_undef_t},      // record
+	{'s', tm_tag_undef_t},      // subtype
+	{'t', tm_tag_class_t},      // table
+	{'T', tm_tag_macro_t},      // trigger
+	{'v', tm_tag_variable_t},   // variable
+	{'i', tm_tag_struct_t},     // index
+	{'e', tm_tag_undef_t},      // event
+	{'U', tm_tag_undef_t},      // publication
+	{'R', tm_tag_undef_t},      // service
+	{'D', tm_tag_undef_t},      // domain
+	{'V', tm_tag_member_t},     // view
+	{'n', tm_tag_undef_t},      // synonym
+	{'x', tm_tag_undef_t},      // mltable
+	{'y', tm_tag_undef_t},      // mlconn
+	{'z', tm_tag_undef_t},      // mlprop
+	{'C', tm_tag_undef_t},      // ccflag
+};
+static TMParserMapGroup group_SQL[] = {
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_prototype_t},
+	{_("Procedures"), TM_ICON_NAMESPACE, tm_tag_namespace_t | tm_tag_package_t},
+	{_("Indexes"), TM_ICON_STRUCT, tm_tag_struct_t},
+	{_("Tables"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Triggers"), TM_ICON_MACRO, tm_tag_macro_t},
+	{_("Views"), TM_ICON_VAR, tm_tag_field_t | tm_tag_member_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
+};
+
 static TMParserMapEntry map_DOCBOOK[] = {
    {'f', tm_tag_function_t},
    {'c', tm_tag_class_t},
@@ -223,70 +318,119 @@ static TMParserMapEntry map_DOCBOOK[] = {
    {'v', tm_tag_variable_t},
    {'s', tm_tag_struct_t},
 };
+static TMParserMapGroup group_DOCBOOK[] = {
+	{_("Chapter"), TM_ICON_NONE, tm_tag_function_t},
+	{_("Section"), TM_ICON_NONE, tm_tag_class_t},
+	{_("Sect1"), TM_ICON_NONE, tm_tag_member_t},
+	{_("Sect2"), TM_ICON_NONE, tm_tag_macro_t},
+	{_("Sect3"), TM_ICON_NONE, tm_tag_variable_t},
+	{_("Appendix"), TM_ICON_NONE, tm_tag_struct_t},
+};
+// no scope information
 static TMParserMapEntry map_ERLANG[] = {
-	{'d', tm_tag_macro_t},
-	{'f', tm_tag_function_t},
-	{'m', tm_tag_undef_t},
-	{'r', tm_tag_struct_t},
-	{'t', tm_tag_typedef_t},
+	{'d', tm_tag_macro_t},     // macro
+	{'f', tm_tag_function_t},  // function
+	{'m', tm_tag_undef_t},     // module
+	{'r', tm_tag_struct_t},    // record
+	{'t', tm_tag_typedef_t},   // type
+};
+static TMParserMapGroup group_ERLANG[] = {
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Structs"), TM_ICON_STRUCT, tm_tag_struct_t},
+	{_("Typedefs / Enums"), TM_ICON_STRUCT, tm_tag_typedef_t},
+	{_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
 };
+// no scope information
 static TMParserMapEntry map_CSS[] = {
-	{'c', tm_tag_class_t},
-	{'s', tm_tag_struct_t},
-	{'i', tm_tag_variable_t},
+	{'c', tm_tag_class_t},     // class
+	{'s', tm_tag_struct_t},    // selector
+	{'i', tm_tag_variable_t},  // id
+};
+static TMParserMapGroup group_CSS[] = {
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("ID Selectors"), TM_ICON_VAR, tm_tag_variable_t},
+	{_("Type Selectors"), TM_ICON_STRUCT, tm_tag_struct_t},
 };
static TMParserMapEntry map_RUBY[] = {
-	{'c', tm_tag_class_t},
-	{'f', tm_tag_method_t},
-	{'m', tm_tag_namespace_t},
-	{'S', tm_tag_member_t},
-	{'C', tm_tag_undef_t},
-	{'A', tm_tag_undef_t},
-	{'a', tm_tag_undef_t},
-	{'L', tm_tag_undef_t},
+	{'c', tm_tag_class_t},      // class
+	{'f', tm_tag_method_t},     // method
+	{'m', tm_tag_namespace_t},  // module
+	{'S', tm_tag_member_t},     // singletonMethod
+	{'C', tm_tag_undef_t},      // constant
+	{'A', tm_tag_undef_t},      // accessor
+	{'a', tm_tag_undef_t},      // alias
+	{'L', tm_tag_undef_t},      // library
+};
+static TMParserMapGroup group_RUBY[] = {
+	{_("Modules"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Singletons"), TM_ICON_STRUCT, tm_tag_member_t},
+	{_("Methods"), TM_ICON_METHOD, tm_tag_method_t},
 };
static TMParserMapEntry map_TCL[] = {
-	{'c', tm_tag_class_t},
-	{'m', tm_tag_member_t},
-	{'p', tm_tag_function_t},
-	{'n', tm_tag_namespace_t},
+	{'c', tm_tag_class_t},      // class
+	{'m', tm_tag_member_t},     // method
+	{'p', tm_tag_function_t},   // procedure
+	{'n', tm_tag_namespace_t},  // module
+};
+static TMParserMapGroup group_TCL[] = {
+	{_("Namespaces"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Methods"), TM_ICON_METHOD, tm_tag_member_t},
+	{_("Procedures"), TM_ICON_OTHER, tm_tag_function_t},
 };
static TMParserMapEntry map_SH[] = {
-	{'a', tm_tag_undef_t},
-	{'f', tm_tag_function_t},
-	{'s', tm_tag_undef_t},
-	{'h', tm_tag_undef_t},
+	{'a', tm_tag_undef_t},     // alias
+	{'f', tm_tag_function_t},  // function
+	{'s', tm_tag_undef_t},     // script
+	{'h', tm_tag_undef_t},     // heredoc
+};
+static TMParserMapGroup group_SH[] = {
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
 };
static TMParserMapEntry map_D[] = {
-	{'c', tm_tag_class_t},
-	{'e', tm_tag_enumerator_t},
-	{'f', tm_tag_function_t},
-	{'g', tm_tag_enum_t},
-	{'i', tm_tag_interface_t},
-	{'m', tm_tag_member_t},
-	{'n', tm_tag_namespace_t},
-	{'p', tm_tag_prototype_t},
-	{'s', tm_tag_struct_t},
-	{'t', tm_tag_typedef_t},
-	{'u', tm_tag_union_t},
-	{'v', tm_tag_variable_t},
-	{'x', tm_tag_externvar_t},
+	{'c', tm_tag_class_t},       // class
+	{'e', tm_tag_enumerator_t},  // enumerator
+	{'f', tm_tag_function_t},    // function
+	{'g', tm_tag_enum_t},        // enum
+	{'i', tm_tag_interface_t},   // interface
+	{'m', tm_tag_member_t},      // member
+	{'n', tm_tag_namespace_t},   // namespace
+	{'p', tm_tag_prototype_t},   // prototype
+	{'s', tm_tag_struct_t},      // struct
+	{'t', tm_tag_typedef_t},     // typedef
+	{'u', tm_tag_union_t},       // union
+	{'v', tm_tag_variable_t},    // variable
+	{'x', tm_tag_externvar_t},   // externvar
+};
+static TMParserMapGroup group_D[] = {
+	{_("Module"), TM_ICON_NONE, tm_tag_namespace_t},
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_prototype_t},
+	{_("Members"), TM_ICON_MEMBER, tm_tag_member_t},
+	{_("Structs"), TM_ICON_STRUCT, tm_tag_struct_t | tm_tag_union_t},
+	{_("Typedefs / Enums"), TM_ICON_STRUCT, tm_tag_typedef_t | tm_tag_enum_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_enumerator_t},
+	{_("Extern Variables"), TM_ICON_VAR, tm_tag_externvar_t},
 };
static TMParserMapEntry map_DIFF[] = {
-	{'m', tm_tag_function_t},
-	{'n', tm_tag_function_t},
-	{'d', tm_tag_function_t},
-	{'h', tm_tag_undef_t},
+	{'m', tm_tag_function_t},  // modifiedFile
+	{'n', tm_tag_function_t},  // newFile
+	{'d', tm_tag_function_t},  // deletedFile
+	{'h', tm_tag_undef_t},     // hunk
+};
+static TMParserMapGroup group_DIFF[] = {
+	{_("Files"), TM_ICON_NONE, tm_tag_function_t},
 };
-/* different parser than in universal-ctags */
 static TMParserMapEntry map_VHDL[] = {
    {'c', tm_tag_variable_t},
    {'t', tm_tag_typedef_t},
@@ -304,333 +448,509 @@ static TMParserMapEntry map_VHDL[] = {
    {'b', tm_tag_member_t},
    {'A', tm_tag_typedef_t},
 };
+static TMParserMapGroup group_VHDL[] = {
+	{_("Package"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
+	{_("Entities"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Architectures"), TM_ICON_STRUCT, tm_tag_struct_t},
+	{_("Types"), TM_ICON_OTHER, tm_tag_typedef_t},
+	{_("Functions / Procedures"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Variables / Signals"), TM_ICON_VAR, tm_tag_variable_t},
+	{_("Processes / Blocks / Components"), TM_ICON_MEMBER, tm_tag_member_t},
+};
static TMParserMapEntry map_LUA[] = {
-	{'f', tm_tag_function_t},
-	{'X', tm_tag_undef_t},
+	{'f', tm_tag_function_t},  // function
+	{'X', tm_tag_undef_t},     // unknown
+};
+static TMParserMapGroup group_LUA[] = {
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
 };
static TMParserMapEntry map_JAVASCRIPT[] = {
-	{'f', tm_tag_function_t},
-	{'c', tm_tag_class_t},
-	{'m', tm_tag_method_t},
-	{'p', tm_tag_member_t},
-	{'C', tm_tag_macro_t},
-	{'v', tm_tag_variable_t},
-	{'g', tm_tag_function_t},
-	{'G', tm_tag_undef_t},
-	{'S', tm_tag_undef_t},
-	{'M', tm_tag_undef_t},
+	{'f', tm_tag_function_t},  // function
+	{'c', tm_tag_class_t},     // class
+	{'m', tm_tag_method_t},    // method
+	{'p', tm_tag_member_t},    // property
+	{'C', tm_tag_macro_t},     // constant
+	{'v', tm_tag_variable_t},  // variable
+	{'g', tm_tag_function_t},  // generator
+	{'G', tm_tag_undef_t},     // getter
+	{'S', tm_tag_undef_t},     // setter
+	{'M', tm_tag_undef_t},     // field
+};
+static TMParserMapGroup group_JAVASCRIPT[] = {
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_method_t},
+	{_("Members"), TM_ICON_MEMBER, tm_tag_member_t},
+	{_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
 };
+// no scope information
 static TMParserMapEntry map_HASKELL[] = {
-	{'t', tm_tag_typedef_t},
-	{'c', tm_tag_macro_t},
-	{'f', tm_tag_function_t},
-	{'m', tm_tag_namespace_t},
+	{'t', tm_tag_typedef_t},    // type
+	{'c', tm_tag_macro_t},      // constructor
+	{'f', tm_tag_function_t},   // function
+	{'m', tm_tag_namespace_t},  // module
+};
+static TMParserMapGroup group_HASKELL[] = {
+	{_("Module"), TM_ICON_NONE, tm_tag_namespace_t},
+	{_("Types"), TM_ICON_NONE, tm_tag_typedef_t},
+	{_("Type constructors"), TM_ICON_NONE, tm_tag_macro_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
 };
static TMParserMapEntry map_CSHARP[] = {
-	{'c', tm_tag_class_t},
-	{'d', tm_tag_macro_t},
-	{'e', tm_tag_enumerator_t},
-	{'E', tm_tag_undef_t},
-	{'f', tm_tag_field_t},
-	{'g', tm_tag_enum_t},
-	{'i', tm_tag_interface_t},
-	{'l', tm_tag_undef_t},
-	{'m', tm_tag_method_t},
-	{'n', tm_tag_namespace_t},
-	{'p', tm_tag_undef_t},
-	{'s', tm_tag_struct_t},
-	{'t', tm_tag_typedef_t},
+	{'c', tm_tag_class_t},       // class
+	{'d', tm_tag_macro_t},       // macro
+	{'e', tm_tag_enumerator_t},  // enumerator
+	{'E', tm_tag_undef_t},       // event
+	{'f', tm_tag_field_t},       // field
+	{'g', tm_tag_enum_t},        // enum
+	{'i', tm_tag_interface_t},   // interface
+	{'l', tm_tag_undef_t},       // local
+	{'m', tm_tag_method_t},      // method
+	{'n', tm_tag_namespace_t},   // namespace
+	{'p', tm_tag_undef_t},       // property
+	{'s', tm_tag_struct_t},      // struct
+	{'t', tm_tag_typedef_t},     // typedef
 };
+#define group_CSHARP group_C
+// no scope information
 static TMParserMapEntry map_FREEBASIC[] = {
-	{'c', tm_tag_macro_t},
-	{'f', tm_tag_function_t},
-	{'l', tm_tag_namespace_t},
-	{'t', tm_tag_struct_t},
-	{'v', tm_tag_variable_t},
-	{'g', tm_tag_externvar_t},
+	{'c', tm_tag_macro_t},      // constant
+	{'f', tm_tag_function_t},   // function
+	{'l', tm_tag_namespace_t},  // label
+	{'t', tm_tag_struct_t},     // type
+	{'v', tm_tag_variable_t},   // variable
+	{'g', tm_tag_externvar_t},  // enum
+};
+static TMParserMapGroup group_FREEBASIC[] = {
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_externvar_t},
+	{_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
+	{_("Types"), TM_ICON_NAMESPACE, tm_tag_struct_t},
+	{_("Labels"), TM_ICON_MEMBER, tm_tag_namespace_t},
 };
+// no scope information
 static TMParserMapEntry map_HAXE[] = {
-	{'m', tm_tag_method_t},
-	{'c', tm_tag_class_t},
-	{'e', tm_tag_enum_t},
-	{'v', tm_tag_variable_t},
-	{'i', tm_tag_interface_t},
-	{'t', tm_tag_typedef_t},
+	{'m', tm_tag_method_t},     // method
+	{'c', tm_tag_class_t},      // class
+	{'e', tm_tag_enum_t},       // enum
+	{'v', tm_tag_variable_t},   // variable
+	{'i', tm_tag_interface_t},  // interface
+	{'t', tm_tag_typedef_t},    // typedef
+};
+static TMParserMapGroup group_HAXE[] = {
+	{_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Methods"), TM_ICON_METHOD, tm_tag_method_t},
+	{_("Types"), TM_ICON_MACRO, tm_tag_typedef_t | tm_tag_enum_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
 };
static TMParserMapEntry map_REST[] = {
-	{'c', tm_tag_namespace_t},
-	{'s', tm_tag_member_t},
-	{'S', tm_tag_macro_t},
-	{'t', tm_tag_variable_t},
-	{'C', tm_tag_undef_t},
-	{'T', tm_tag_undef_t},
-	{'d', tm_tag_undef_t},
+	{'c', tm_tag_namespace_t},  // chapter
+	{'s', tm_tag_member_t},     // section
+	{'S', tm_tag_macro_t},      // subsection
+	{'t', tm_tag_variable_t},   // subsubsection
+	{'C', tm_tag_undef_t},      // citation
+	{'T', tm_tag_undef_t},      // target
+	{'d', tm_tag_undef_t},      // substdef
+};
+static TMParserMapGroup group_REST[] = {
+	{_("Chapter"), TM_ICON_NONE, tm_tag_namespace_t},
+	{_("Section"), TM_ICON_NONE, tm_tag_member_t},
+	{_("Subsection"), TM_ICON_NONE, tm_tag_macro_t},
+	{_("Subsubsection"), TM_ICON_NONE, tm_tag_variable_t},
 };
+// no scope information
 static TMParserMapEntry map_HTML[] = {
-	{'a', tm_tag_member_t},
-	{'c', tm_tag_undef_t},
-	{'h', tm_tag_namespace_t},
-	{'i', tm_tag_class_t},
-	{'j', tm_tag_variable_t},
-	{'C', tm_tag_undef_t},
-	{'I', tm_tag_undef_t},
-	{'J', tm_tag_undef_t},
+	{'a', tm_tag_member_t},     // anchor
+	{'c', tm_tag_undef_t},      // class
+	{'h', tm_tag_namespace_t},  // heading1
+	{'i', tm_tag_class_t},      // heading2
+	{'j', tm_tag_variable_t},   // heading3
+	{'C', tm_tag_undef_t},      // stylesheet
+	{'I', tm_tag_undef_t},      // id
+	{'J', tm_tag_undef_t},      // script
+};
+static TMParserMapGroup group_HTML[] = {
+	{_("Functions"), TM_ICON_NONE, tm_tag_function_t},  // javascript functions from subparser
+	{_("Anchors"), TM_ICON_NONE, tm_tag_member_t},
+	{_("H1 Headings"), TM_ICON_NONE, tm_tag_namespace_t},
+	{_("H2 Headings"), TM_ICON_NONE, tm_tag_class_t},
+	{_("H3 Headings"), TM_ICON_NONE, tm_tag_variable_t},
 };
static TMSubparserMapEntry subparser_HTML_javascript_map[] = {
    {tm_tag_function_t, tm_tag_function_t},
 };
static TMParserMapEntry map_F77[] = {
-	{'b', tm_tag_undef_t},
-	{'c', tm_tag_macro_t},
-	{'e', tm_tag_undef_t},
-	{'f', tm_tag_function_t},
-	{'i', tm_tag_interface_t},
-	{'k', tm_tag_member_t},
-	{'l', tm_tag_undef_t},
-	{'L', tm_tag_undef_t},
-	{'m', tm_tag_namespace_t},
-	{'n', tm_tag_undef_t},
-	{'p', tm_tag_struct_t},
-	{'s', tm_tag_method_t},
-	{'t', tm_tag_class_t},
-	{'v', tm_tag_variable_t},
-	{'E', tm_tag_enum_t},
-	{'N', tm_tag_enumerator_t},
+	{'b', tm_tag_undef_t},       // blockData
+	{'c', tm_tag_macro_t},       // common
+	{'e', tm_tag_undef_t},       // entry
+	{'f', tm_tag_function_t},    // function
+	{'i', tm_tag_interface_t},   // interface
+	{'k', tm_tag_member_t},      // component
+	{'l', tm_tag_undef_t},       // label
+	{'L', tm_tag_undef_t},       // local
+	{'m', tm_tag_namespace_t},   // module
+	{'n', tm_tag_undef_t},       // namelist
+	{'p', tm_tag_struct_t},      // program
+	{'s', tm_tag_method_t},      // subroutine
+	{'t', tm_tag_class_t},       // type
+	{'v', tm_tag_variable_t},    // variable
+	{'E', tm_tag_enum_t},        // enum
+	{'N', tm_tag_enumerator_t},  // enumerator
+};
+static TMParserMapGroup group_F77[] = {
+	{_("Module"), TM_ICON_CLASS, tm_tag_namespace_t},
+	{_("Programs"), TM_ICON_CLASS, tm_tag_struct_t},
+	{_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
+	{_("Functions / Subroutines"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_method_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_enumerator_t},
+	{_("Types"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Components"), TM_ICON_MEMBER, tm_tag_member_t},
+	{_("Blocks"), TM_ICON_MEMBER, tm_tag_macro_t},
+	{_("Enums"), TM_ICON_STRUCT, tm_tag_enum_t},
 };
#define map_FORTRAN map_F77
+#define group_FORTRAN group_F77
-/* different parser than in universal-ctags */
 static TMParserMapEntry map_MATLAB[] = {
-	{'f', tm_tag_function_t},
-	{'s', tm_tag_struct_t},
+	{'f', tm_tag_function_t},  // function
+	{'s', tm_tag_struct_t},    // struct
+};
+static TMParserMapGroup group_MATLAB[] = {
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Structures"), TM_ICON_STRUCT, tm_tag_struct_t},
 };
#define map_CUDA map_C
+#define group_CUDA group_C
-/* not in universal-ctags */
 static TMParserMapEntry map_VALA[] = {
-	{'c', tm_tag_class_t},
-	{'d', tm_tag_macro_t},
-	{'e', tm_tag_enumerator_t},
-	{'f', tm_tag_field_t},
-	{'g', tm_tag_enum_t},
-	{'i', tm_tag_interface_t},
-	{'l', tm_tag_undef_t},
-	{'m', tm_tag_method_t},
-	{'n', tm_tag_namespace_t},
-	{'p', tm_tag_undef_t},
-	{'S', tm_tag_undef_t},
-	{'s', tm_tag_struct_t},
+	{'c', tm_tag_class_t},       // class
+	{'d', tm_tag_macro_t},       // macro
+	{'e', tm_tag_enumerator_t},  // enumerator
+	{'f', tm_tag_field_t},       // field
+	{'g', tm_tag_enum_t},        // enum
+	{'i', tm_tag_interface_t},   // interface
+	{'l', tm_tag_undef_t},       // local
+	{'m', tm_tag_method_t},      // method
+	{'n', tm_tag_namespace_t},   // namespace
+	{'p', tm_tag_undef_t},       // property
+	{'S', tm_tag_undef_t},       // signal
+	{'s', tm_tag_struct_t},      // struct
 };
+#define group_VALA group_C
-/* not in universal-ctags */
 static TMParserMapEntry map_ACTIONSCRIPT[] = {
-	{'f', tm_tag_function_t},
-	{'c', tm_tag_class_t},
-	{'i', tm_tag_interface_t},
-	{'P', tm_tag_package_t},
-	{'m', tm_tag_method_t},
-	{'p', tm_tag_member_t},
-	{'v', tm_tag_variable_t},
-	{'l', tm_tag_variable_t},
-	{'C', tm_tag_macro_t},
-	{'I', tm_tag_externvar_t},
-	{'x', tm_tag_other_t},
+	{'f', tm_tag_function_t},   // function
+	{'c', tm_tag_class_t},      // class
+	{'i', tm_tag_interface_t},  // interface
+	{'P', tm_tag_package_t},    // package
+	{'m', tm_tag_method_t},     // method
+	{'p', tm_tag_member_t},     // property
+	{'v', tm_tag_variable_t},   // variable
+	{'l', tm_tag_variable_t},   // localvar
+	{'C', tm_tag_macro_t},      // constant
+	{'I', tm_tag_externvar_t},  // import
+	{'x', tm_tag_other_t},      // mxtag
+};
+static TMParserMapGroup group_ACTIONSCRIPT[] = {
+	{_("Imports"), TM_ICON_NAMESPACE, tm_tag_externvar_t},
+	{_("Package"), TM_ICON_NAMESPACE, tm_tag_package_t},
+	{_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t| tm_tag_method_t},
+	{_("Properties"), TM_ICON_MEMBER, tm_tag_member_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
+	{_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
+	{_("Other"), TM_ICON_OTHER, tm_tag_other_t},
 };
static TMParserMapEntry map_NSIS[] = {
-	{'s', tm_tag_namespace_t},
-	{'f', tm_tag_function_t},
-	{'v', tm_tag_variable_t},
-	{'d', tm_tag_undef_t},
-	{'m', tm_tag_undef_t},
-	{'S', tm_tag_undef_t},
-	{'p', tm_tag_undef_t},
-	{'l', tm_tag_undef_t},
-	{'i', tm_tag_undef_t},
+	{'s', tm_tag_namespace_t},  // section
+	{'f', tm_tag_function_t},   // function
+	{'v', tm_tag_variable_t},   // variable
+	{'d', tm_tag_undef_t},      // definition
+	{'m', tm_tag_undef_t},      // macro
+	{'S', tm_tag_undef_t},      // sectionGroup
+	{'p', tm_tag_undef_t},      // macroparam
+	{'l', tm_tag_undef_t},      // langstr
+	{'i', tm_tag_undef_t},      // script
+};
+static TMParserMapGroup group_NSIS[] = {
+	{_("Sections"), TM_ICON_OTHER, tm_tag_namespace_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
 };
-/* not in universal-ctags */
 static TMParserMapEntry map_MARKDOWN[] = {
    {'v', tm_tag_variable_t},
 };
+static TMParserMapGroup group_MARKDOWN[] = {
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
+};
static TMParserMapEntry map_TXT2TAGS[] = {
-	{'s', tm_tag_member_t},
+	{'s', tm_tag_member_t},  // section
 };
+#define group_TXT2TAGS group_REST
+// no scope information
 static TMParserMapEntry map_ABC[] = {
-	{'s', tm_tag_member_t},
+	{'s', tm_tag_member_t},  // section
 };
+#define group_ABC group_REST
static TMParserMapEntry map_VERILOG[] = {
-	{'c', tm_tag_variable_t},
-	{'e', tm_tag_typedef_t},
-	{'f', tm_tag_function_t},
-	{'m', tm_tag_class_t},
-	{'n', tm_tag_variable_t},
-	{'p', tm_tag_variable_t},
-	{'r', tm_tag_variable_t},
-	{'t', tm_tag_function_t},
-	{'b', tm_tag_undef_t},
-	{'i', tm_tag_undef_t},
+	{'c', tm_tag_variable_t},  // constant
+	{'e', tm_tag_typedef_t},   // event
+	{'f', tm_tag_function_t},  // function
+	{'m', tm_tag_class_t},     // module
+	{'n', tm_tag_variable_t},  // net
+	{'p', tm_tag_variable_t},  // port
+	{'r', tm_tag_variable_t},  // register
+	{'t', tm_tag_function_t},  // task
+	{'b', tm_tag_undef_t},     // block
+	{'i', tm_tag_undef_t},     // instance
+};
+static TMParserMapGroup group_VERILOG[] = {
+	{_("Events"), TM_ICON_MACRO, tm_tag_typedef_t},
+	{_("Modules"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Functions / Tasks"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
 };
static TMParserMapEntry map_R[] = {
-	{'f', tm_tag_function_t},
-	{'l', tm_tag_other_t},
-	{'s', tm_tag_other_t},
-	{'g', tm_tag_undef_t},
-	{'v', tm_tag_undef_t},
-	{'z', tm_tag_undef_t},
-	{'c', tm_tag_undef_t},
-	{'L', tm_tag_undef_t},
-	{'d', tm_tag_undef_t},
-	{'n', tm_tag_undef_t},
+	{'f', tm_tag_function_t},  // function
+	{'l', tm_tag_other_t},     // library
+	{'s', tm_tag_other_t},     // source
+	{'g', tm_tag_undef_t},     // globalVar
+	{'v', tm_tag_undef_t},     // functionVar
+	{'z', tm_tag_undef_t},     // parameter
+	{'c', tm_tag_undef_t},     // vector
+	{'L', tm_tag_undef_t},     // list
+	{'d', tm_tag_undef_t},     // dataframe
+	{'n', tm_tag_undef_t},     // nameattr
+};
+static TMParserMapGroup group_R[] = {
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Other"), TM_ICON_NONE, tm_tag_other_t},
 };
static TMParserMapEntry map_COBOL[] = {
-	{'d', tm_tag_variable_t},
-	{'D', tm_tag_interface_t},
-	{'f', tm_tag_function_t},
-	{'g', tm_tag_struct_t},
-	{'p', tm_tag_macro_t},
-	{'P', tm_tag_class_t},
-	{'s', tm_tag_namespace_t},
-	{'S', tm_tag_externvar_t},
+	{'f', tm_tag_function_t},   // fd
+	{'g', tm_tag_struct_t},     // group
+	{'P', tm_tag_class_t},      // program
+	{'s', tm_tag_namespace_t},  // section
+	{'D', tm_tag_interface_t},  // division
+	{'p', tm_tag_macro_t},      // paragraph
+	{'d', tm_tag_variable_t},   // data
+	{'S', tm_tag_externvar_t},  // sourcefile
+};
+static TMParserMapGroup group_COBOL[] = {
+	{_("Program"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("File"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Divisions"), TM_ICON_NAMESPACE, tm_tag_interface_t},
+	{_("Sections"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
+	{_("Paragraph"), TM_ICON_OTHER, tm_tag_macro_t},
+	{_("Group"), TM_ICON_STRUCT, tm_tag_struct_t},
+	{_("Data"), TM_ICON_VAR, tm_tag_variable_t},
+	{_("Copies"), TM_ICON_NAMESPACE, tm_tag_externvar_t},
 };
static TMParserMapEntry map_OBJC[] = {
-	{'i', tm_tag_interface_t},
-	{'I', tm_tag_undef_t},
-	{'P', tm_tag_undef_t},
-	{'m', tm_tag_method_t},
-	{'c', tm_tag_class_t},
-	{'v', tm_tag_variable_t},
-	{'E', tm_tag_field_t},
-	{'f', tm_tag_function_t},
-	{'p', tm_tag_undef_t},
-	{'t', tm_tag_typedef_t},
-	{'s', tm_tag_struct_t},
-	{'e', tm_tag_enum_t},
-	{'M', tm_tag_macro_t},
-	{'C', tm_tag_undef_t},
+	{'i', tm_tag_interface_t},  // interface
+	{'I', tm_tag_undef_t},      // implementation
+	{'P', tm_tag_undef_t},      // protocol
+	{'m', tm_tag_method_t},     // method
+	{'c', tm_tag_class_t},      // class
+	{'v', tm_tag_variable_t},   // var
+	{'E', tm_tag_field_t},      // field
+	{'f', tm_tag_function_t},   // function
+	{'p', tm_tag_undef_t},      // property
+	{'t', tm_tag_typedef_t},    // typedef
+	{'s', tm_tag_struct_t},     // struct
+	{'e', tm_tag_enum_t},       // enum
+	{'M', tm_tag_macro_t},      // macro
+	{'C', tm_tag_undef_t},      // category
 };
+#define group_OBJC group_C
static TMParserMapEntry map_ASCIIDOC[] = {
-	{'c', tm_tag_namespace_t},
-	{'s', tm_tag_member_t},
-	{'S', tm_tag_macro_t},
-	{'t', tm_tag_variable_t},
-	{'T', tm_tag_struct_t},
-	{'u', tm_tag_undef_t},
-	{'a', tm_tag_undef_t},
+	{'c', tm_tag_namespace_t},  //chapter
+	{'s', tm_tag_member_t},     //section
+	{'S', tm_tag_macro_t},      //subsection
+	{'t', tm_tag_variable_t},   //subsubsection
+	{'T', tm_tag_struct_t},     //l4subsection
+	{'u', tm_tag_undef_t},      //l5subsection
+	{'a', tm_tag_undef_t},      //anchor
+};
+static TMParserMapGroup group_ASCIIDOC[] = {
+	{_("Document"), TM_ICON_NONE, tm_tag_namespace_t},
+	{_("Section Level 1"), TM_ICON_NONE, tm_tag_member_t},
+	{_("Section Level 2"), TM_ICON_NONE, tm_tag_macro_t},
+	{_("Section Level 3"), TM_ICON_NONE, tm_tag_variable_t},
+	{_("Section Level 4"), TM_ICON_NONE, tm_tag_struct_t},
 };
+// no scope information
 static TMParserMapEntry map_ABAQUS[] = {
-	{'p', tm_tag_class_t},
-	{'a', tm_tag_member_t},
-	{'s', tm_tag_interface_t},
+	{'p', tm_tag_class_t},      // part
+	{'a', tm_tag_member_t},     // assembly
+	{'s', tm_tag_interface_t},  // step
+};
+static TMParserMapGroup group_ABAQUS[] = {
+	{_("Parts"), TM_ICON_NONE, tm_tag_class_t},
+	{_("Assembly"), TM_ICON_NONE, tm_tag_member_t},
+	{_("Steps"), TM_ICON_NONE, tm_tag_interface_t},
 };
static TMParserMapEntry map_RUST[] = {
-	{'n', tm_tag_namespace_t},
-	{'s', tm_tag_struct_t},
-	{'i', tm_tag_interface_t},
-	{'c', tm_tag_class_t},
-	{'f', tm_tag_function_t},
-	{'g', tm_tag_enum_t},
-	{'t', tm_tag_typedef_t},
-	{'v', tm_tag_variable_t},
-	{'M', tm_tag_macro_t},
-	{'m', tm_tag_field_t},
-	{'e', tm_tag_enumerator_t},
-	{'P', tm_tag_method_t},
+	{'n', tm_tag_namespace_t},   // module
+	{'s', tm_tag_struct_t},      // struct
+	{'i', tm_tag_interface_t},   // interface
+	{'c', tm_tag_class_t},       // implementation
+	{'f', tm_tag_function_t},    // function
+	{'g', tm_tag_enum_t},        // enum
+	{'t', tm_tag_typedef_t},     // typedef
+	{'v', tm_tag_variable_t},    // variable
+	{'M', tm_tag_macro_t},       // macro
+	{'m', tm_tag_field_t},       // field
+	{'e', tm_tag_enumerator_t},  // enumerator
+	{'P', tm_tag_method_t},      // method
+};
+static TMParserMapGroup group_RUST[] = {
+	{_("Modules"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
+	{_("Structures"), TM_ICON_STRUCT, tm_tag_struct_t},
+	{_("Traits)"), TM_ICON_CLASS, tm_tag_interface_t},
+	{_("Implementations"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_method_t},
+	{_("Typedefs / Enums"), TM_ICON_STRUCT, tm_tag_typedef_t | tm_tag_enum_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_enumerator_t},
+	{_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
+	{_("Methods"), TM_ICON_MEMBER, tm_tag_field_t},
 };
static TMParserMapEntry map_GO[] = {
-	{'p', tm_tag_namespace_t},
-	{'f', tm_tag_function_t},
-	{'c', tm_tag_macro_t},
-	{'t', tm_tag_typedef_t},
-	{'v', tm_tag_variable_t},
-	{'s', tm_tag_struct_t},
-	{'i', tm_tag_interface_t},
-	{'m', tm_tag_member_t},
-	{'M', tm_tag_undef_t},
-	{'n', tm_tag_undef_t},
-	{'u', tm_tag_undef_t},
-	{'P', tm_tag_undef_t},
-	{'a', tm_tag_undef_t},
-	{'R', tm_tag_undef_t},
+	{'p', tm_tag_namespace_t},  // package
+	{'f', tm_tag_function_t},   // func
+	{'c', tm_tag_macro_t},      // const
+	{'t', tm_tag_typedef_t},    // type
+	{'v', tm_tag_variable_t},   // var
+	{'s', tm_tag_struct_t},     // struct
+	{'i', tm_tag_interface_t},  // interface
+	{'m', tm_tag_member_t},     // member
+	{'M', tm_tag_undef_t},      // anonMember
+	{'n', tm_tag_undef_t},      // methodSpec
+	{'u', tm_tag_undef_t},      // unknown
+	{'P', tm_tag_undef_t},      // packageName
+	{'a', tm_tag_undef_t},      // talias
+	{'R', tm_tag_undef_t},      // receiver
+};
+static TMParserMapGroup group_GO[] = {
+	{_("Package"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
+	{_("Structs"), TM_ICON_STRUCT, tm_tag_struct_t},
+	{_("Types"), TM_ICON_STRUCT, tm_tag_typedef_t},
+	{_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
+	{_("Members"), TM_ICON_MEMBER, tm_tag_member_t},
 };
static TMParserMapEntry map_JSON[] = {
-	{'o', tm_tag_member_t},
-	{'a', tm_tag_member_t},
-	{'n', tm_tag_member_t},
-	{'s', tm_tag_member_t},
-	{'b', tm_tag_member_t},
-	{'z', tm_tag_member_t},
+	{'o', tm_tag_member_t},  // object
+	{'a', tm_tag_member_t},  // array
+	{'n', tm_tag_member_t},  // number
+	{'s', tm_tag_member_t},  // string
+	{'b', tm_tag_member_t},  // boolean
+	{'z', tm_tag_member_t},  // null
+};
+static TMParserMapGroup group_JSON[] = {
+	{_("Members"), TM_ICON_MEMBER, tm_tag_member_t},
 };
/* Zephir, same as PHP */
 #define map_ZEPHIR map_PHP
+#define group_ZEPHIR group_PHP
-/* not in universal-ctags */
 static TMParserMapEntry map_POWERSHELL[] = {
-	{'f', tm_tag_function_t},
-	{'v', tm_tag_variable_t},
+	{'f', tm_tag_function_t},  // function
+	{'v', tm_tag_variable_t},  // variable
+};
+static TMParserMapGroup group_POWERSHELL[] = {
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
 };
static TMParserMapEntry map_JULIA[] = {
-	{'c', tm_tag_variable_t},
-	{'f', tm_tag_function_t},
-	{'g', tm_tag_member_t},
-	{'m', tm_tag_macro_t},
-	{'n', tm_tag_namespace_t},
-	{'s', tm_tag_struct_t},
-	{'t', tm_tag_typedef_t},
+	{'c', tm_tag_variable_t},   // constant
+	{'f', tm_tag_function_t},   // function
+	{'g', tm_tag_member_t},     // field
+	{'m', tm_tag_macro_t},      // macro
+	{'n', tm_tag_namespace_t},  // module
+	{'s', tm_tag_struct_t},     // struct
+	{'t', tm_tag_typedef_t},    // type
     /* defined as externvar to get those excluded as forward type in symbols.c:goto_tag()
      * so we can jump to the real implementation (if known) instead of to the import statement */
-	{'x', tm_tag_externvar_t},
+	{'x', tm_tag_externvar_t},  // unknown
+};
+static TMParserMapGroup group_JULIA[] = {
+	{_("Constants"), TM_ICON_VAR, tm_tag_variable_t},
+	{_("Modules"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
+	{_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
+	{_("Fields"), TM_ICON_MEMBER, tm_tag_member_t},
+	{_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
+	{_("Structures"), TM_ICON_STRUCT, tm_tag_struct_t},
+	{_("Types"), TM_ICON_CLASS, tm_tag_typedef_t},
+	{_("Unknowns"), TM_ICON_OTHER, tm_tag_externvar_t},
 };
static TMParserMapEntry map_CPREPROCESSOR[] = {
-	{'d', tm_tag_undef_t},
-	{'h', tm_tag_undef_t},
-	{'D', tm_tag_undef_t},
+	{'d', tm_tag_undef_t},  // macro
+	{'h', tm_tag_undef_t},  // header
+	{'D', tm_tag_undef_t},  // parameter
 };
+#define group_CPREPROCESSOR group_C
+
 static TMParserMapEntry map_GDSCRIPT[] = {
-	{'c', tm_tag_class_t},
-	{'m', tm_tag_method_t},
-	{'v', tm_tag_variable_t},
-	{'C', tm_tag_variable_t},
-	{'g', tm_tag_enum_t},
-	{'e', tm_tag_variable_t},
-	{'z', tm_tag_other_t},
-	{'l', tm_tag_other_t},
-	{'s', tm_tag_variable_t},
+	{'c', tm_tag_class_t},     // class
+	{'m', tm_tag_method_t},    // method
+	{'v', tm_tag_variable_t},  // variable
+	{'C', tm_tag_variable_t},  // const
+	{'g', tm_tag_enum_t},      // enum
+	{'e', tm_tag_variable_t},  // enumerator
+	{'z', tm_tag_other_t},     // parameter
+	{'l', tm_tag_other_t},     // local
+	{'s', tm_tag_variable_t},  // signal
+};
+static TMParserMapGroup group_GDSCRIPT[] = {
+	{_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
+	{_("Methods"), TM_ICON_MACRO, tm_tag_method_t},
+	{_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
+	{_("Enums"), TM_ICON_STRUCT, tm_tag_enum_t},
+	{_("Other"), TM_ICON_OTHER, tm_tag_other_t},
 };
typedef struct
 {
     TMParserMapEntry *entries;
     guint size;
+    TMParserMapGroup *groups;
+    guint group_num;
 } TMParserMap;
-#define MAP_ENTRY(lang) [TM_PARSER_##lang] = {map_##lang, G_N_ELEMENTS(map_##lang)}
+#define MAP_ENTRY(lang) [TM_PARSER_##lang] = {map_##lang, G_N_ELEMENTS(map_##lang), group_##lang, G_N_ELEMENTS(group_##lang)}
/* keep in sync with TM_PARSER_* definitions in the header */
 static TMParserMap parser_map[] = {
@@ -725,6 +1045,46 @@ gchar tm_parser_get_tag_kind(TMTagType type, TMParserType lang)
 }
+gint tm_parser_get_sidebar_group(TMParserType lang, TMTagType type)
+{
+	TMParserMap *map;
+	guint i;
+
+	if (lang >= TM_PARSER_COUNT)
+		return -1;
+
+	map = &parser_map[lang];
+	for (i = 0; i < map->group_num; i++)
+	{
+		if (map->groups[i].types & type)
+			return i;
+	}
+	return -1;
+}
+
+
+const gchar *tm_parser_get_sidebar_info(TMParserType lang, gint group, guint *icon)
+{
+	TMParserMap *map;
+	TMParserMapGroup *grp;
+
+	if (lang >= TM_PARSER_COUNT)
+		return NULL;
+
+	map = &parser_map[lang];
+	if (group >= (gint)map->group_num)
+		return NULL;
+
+	grp = &map->groups[group];
+	*icon = grp->icon;
+#ifdef GETTEXT_PACKAGE
+	return g_dgettext(GETTEXT_PACKAGE, grp->name);
+#else
+	return grp->name;
+#endif
+}
+
+
 static void add_subparser(TMParserType lang, TMParserType sublang, TMSubparserMapEntry *map, guint map_size)
 {
    guint i;
@@ -796,6 +1156,8 @@ void tm_parser_verify_type_mappings(void)
    	const gchar *kinds = tm_ctags_get_lang_kinds(lang);
    	TMParserMap *map = &parser_map[lang];
    	gchar presence_map[256];
+		TMTagType lang_types = 0;
+		TMTagType group_types = 0;
    	guint i;
if (! map->entries || map->size < 1)
@@ -832,6 +1194,7 @@ void tm_parser_verify_type_mappings(void)
    				kinds[i], tm_ctags_get_lang_name(lang));
presence_map[(unsigned char) map->entries[i].kind]++;
+			lang_types |= map->entries[i].type;
    	}
for (i = 0; i < sizeof(presence_map); i++)
@@ -840,6 +1203,13 @@ void tm_parser_verify_type_mappings(void)
    			g_error("Duplicate tag type '%c' found for %s",
    				(gchar)i, tm_ctags_get_lang_name(lang));
    	}
+
+		for (i = 0; i < map->group_num; i++)
+			group_types |= map->groups[i].types;
+
+		if ((group_types & lang_types) != lang_types)
+			g_warning("Not all tag types mapped to symbol tree groups for %s",
+				tm_ctags_get_lang_name(lang));
    }
 }
Modified: src/tagmanager/tm_parser.h
18 lines changed, 18 insertions(+), 0 deletions(-)
===================================================================
@@ -115,13 +115,31 @@ enum
    TM_PARSER_COUNT
 };
+/* keep in sync with icon names in symbols.c */
+enum
+{
+	TM_ICON_CLASS,
+	TM_ICON_MACRO,
+	TM_ICON_MEMBER,
+	TM_ICON_METHOD,
+	TM_ICON_NAMESPACE,
+	TM_ICON_OTHER,
+	TM_ICON_STRUCT,
+	TM_ICON_VAR,
+	TM_ICON_NONE,
+	TM_N_ICONS = TM_ICON_NONE
+};
void tm_parser_verify_type_mappings(void);
TMTagType tm_parser_get_tag_type(gchar kind, TMParserType lang);
gchar tm_parser_get_tag_kind(TMTagType type, TMParserType lang);
+gint tm_parser_get_sidebar_group(TMParserType lang, TMTagType type);
+
+const gchar *tm_parser_get_sidebar_info(TMParserType lang, gint group, guint *icon);
+
 TMTagType tm_parser_get_subparser_type(TMParserType lang, TMParserType sublang, TMTagType type);
gint tm_parser_scope_autocomplete_suffix(TMParserType lang, const gchar *str);
--------------
This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

    