[geany/geany] 5d9376: Add explicit mapping of ctags tag types to Geany tag types
Jiří Techet
git-noreply at xxxxx
Fri Jun 10 21:57:31 UTC 2016
Branch: refs/heads/master
Author: Jiří Techet <techet at gmail.com>
Committer: Jiří Techet <techet at gmail.com>
Date: Tue, 22 Mar 2016 16:03:16 UTC
Commit: 5d9376ea801a6e6c3ec22748741362a3a2eff7ac
https://github.com/geany/geany/commit/5d9376ea801a6e6c3ec22748741362a3a2eff7ac
Log Message:
-----------
Add explicit mapping of ctags tag types to Geany tag types
At the moment tag types are changed in ctags to match the types Geany
uses internally. This introduces differences between the parsers used
in ctags and the ones used in Geany.
Instead, perform the "ctags tag type"->"geany tag type" mapping explicitly
in TM and leave the tag types in individual parsers identical to ctags.
For parsers which are present in ctags (and which don't seem to be
completely different from the parsers used in Geany) revert the tag type
change in the parsers so the parser tag definitions match universal-ctags.
This patch doesn't do anything with the tag types of parsers not present
in universal-ctags and leaves them as they are.
Parsers which previously had a mapping to an non-existent Geany type have
now the mapping explicitly set to tm_tag_undef_t. Since the mapping is now
made through the one-letter type, some of the parsers had to be adjusted
because they used single letter for multiple tag types (probably by
mistake).
Because the whole mapping process might be a bit fragile and error-prone
to changes in ctags parsers, the patch also performs some consistency
checks:
* whether the parser number in ctags/TM matches
* whether for the given language the tag type number is identical in TM
mapping and ctags definition
* whether all tag types defined in ctags parser are mapped in TM and in
reverse, whether all mapped tags in TM are defined in ctags parser
* whether there aren't duplicate tag types
Unfortunately the checks are possible only for parsers not using regex
because regex definitions are not exposed by ctags (TODO).
A bonus side effect of the changes is we can now use real tag types defined
for each languages in ctags when parsing ctags tag files instead of
using the hard-coded static values which mostly work just for C/C++.
Modified Paths:
--------------
tagmanager/ctags/actionscript.c
tagmanager/ctags/asm.c
tagmanager/ctags/basic.c
tagmanager/ctags/c.c
tagmanager/ctags/cobol.c
tagmanager/ctags/css.c
tagmanager/ctags/erlang.c
tagmanager/ctags/fortran.c
tagmanager/ctags/go.c
tagmanager/ctags/html.c
tagmanager/ctags/js.c
tagmanager/ctags/json.c
tagmanager/ctags/make.c
tagmanager/ctags/parse.c
tagmanager/ctags/parse.h
tagmanager/ctags/pascal.c
tagmanager/ctags/perl.c
tagmanager/ctags/php.c
tagmanager/ctags/python.c
tagmanager/ctags/r.c
tagmanager/ctags/ruby.c
tagmanager/ctags/rust.c
tagmanager/ctags/sql.c
tagmanager/ctags/tcl.c
tagmanager/ctags/verilog.c
tagmanager/ctags/vhdl.c
tagmanager/src/Makefile.am
tagmanager/src/tm_ctags_wrappers.c
tagmanager/src/tm_ctags_wrappers.h
tagmanager/src/tm_parser.c
tagmanager/src/tm_parser.h
tagmanager/src/tm_source_file.c
tagmanager/src/tm_tag.c
tagmanager/src/tm_tag.h
Modified: tagmanager/ctags/actionscript.c
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -50,7 +50,7 @@ static void installActionScriptRegex (const langType language)
/* Getters and setters */
addTagRegex (language, "^[ \t]*[(public|static|internal|final|override)( \t)]*function[ \t]+(set|get)[ \t]+([A-Za-z0-9_]+)[ \t]*\\(",
- "\\2 \\1", "f,field,fields", NULL);
+ "\\2 \\1", "l,field,fields", NULL);
/* Variables */
addTagRegex (language, "^[ \t]*[(private|public|static|protected|internal)( \t)]*var[ \t]+([A-Za-z0-9_]+)([ \t]*\\:[ \t]*([A-Za-z0-9_]+))*[ \t]*",
@@ -82,7 +82,7 @@ static void installActionScriptRegex (const langType language)
/* Prototypes (Put this in for AS1 compatibility...) */
addTagRegex (language, ".*\\.prototype\\.([A-Za-z0-9 ]+)[ \t]*\\=([ \t]*)function( [ \t]?)*\\(",
- "\\1", "p,prototype", NULL);
+ "\\1", "r,prototype", NULL);
}
/* Create parser definition structure */
Modified: tagmanager/ctags/asm.c
8 lines changed, 4 insertions(+), 4 deletions(-)
===================================================================
@@ -65,10 +65,10 @@ typedef struct {
static langType Lang_asm;
static kindOption AsmKinds [] = {
- { TRUE, 'd', "macro", "defines" },
- { TRUE, 'l', "namespace", "labels" },
- { TRUE, 'm', "function", "macros" },
- { TRUE, 't', "struct", "types (structs and records)" }
+ { TRUE, 'd', "define", "defines" },
+ { TRUE, 'l', "label", "labels" },
+ { TRUE, 'm', "macro", "macros" },
+ { TRUE, 't', "type", "types (structs and records)" }
};
static const asmKeyword AsmKeywords [] = {
Modified: tagmanager/ctags/basic.c
8 lines changed, 4 insertions(+), 4 deletions(-)
===================================================================
@@ -39,12 +39,12 @@ typedef struct {
} KeyWord;
static kindOption BasicKinds[] = {
- {TRUE, 'c', "macro", "constants"},
+ {TRUE, 'c', "constant", "constants"},
{TRUE, 'f', "function", "functions"},
- {TRUE, 'l', "namespace", "labels"},
- {TRUE, 't', "struct", "types"},
+ {TRUE, 'l', "label", "labels"},
+ {TRUE, 't', "type", "types"},
{TRUE, 'v', "variable", "variables"},
- {TRUE, 'g', "externvar", "enumerations"}
+ {TRUE, 'g', "enum", "enumerations"}
};
static KeyWord freebasic_keywords[] = {
Modified: tagmanager/ctags/c.c
14 lines changed, 7 insertions(+), 7 deletions(-)
===================================================================
@@ -332,13 +332,13 @@ typedef enum
} javaKind;
static kindOption JavaKinds [] = {
- { TRUE, 'c', "class", "classes"},
- { TRUE, 'f', "field", "fields"},
- { TRUE, 'i', "interface", "interfaces"},
- { TRUE, 'm', "method", "methods"},
- { TRUE, 'p', "package", "packages"},
- { TRUE, 'e', "enumerator", "enumerators (values inside an enumeration)"},
- { TRUE, 'g', "enum", "enumeration names"},
+ { TRUE, 'c', "class", "classes"},
+ { TRUE, 'f', "field", "fields"},
+ { TRUE, 'i', "interface", "interfaces"},
+ { TRUE, 'm', "method", "methods"},
+ { TRUE, 'p', "package", "packages"},
+ { TRUE, 'e', "enumConstant", "enum constants"},
+ { TRUE, 'g', "enum", "enum types"},
};
typedef enum
Modified: tagmanager/ctags/cobol.c
14 lines changed, 7 insertions(+), 7 deletions(-)
===================================================================
@@ -20,18 +20,18 @@
static void installCobolRegex (const langType language)
{
- addTagRegex (language, "^[ \t]*[0-9]+[ \t]+([A-Z0-9][A-Z0-9-]*)[ \t]+(BLANK|OCCURS|IS|JUST|PIC|REDEFINES|RENAMES|SIGN|SYNC|USAGE|VALUE)",
- "\\1", "d,variable,data items", "i");
+ addTagRegex (language, "^[ \t]*[0-9]+[ \t]+([A-Z0-9][A-Z0-9-]*)[ \t]+(BLANK|OCCURS|IS|JUST|PIC|REDEFINES|RENAMES|SIGN|SYNC|USAGE|VALUE)",
+ "\\1", "d,data,data items", "i");
addTagRegex (language, "^[ \t]*[FSR]D[ \t]+([A-Z0-9][A-Z0-9-]*)\\.",
- "\\1", "f,function,file descriptions (FD, SD, RD)", "i");
+ "\\1", "f,file,file descriptions (FD, SD, RD)", "i");
addTagRegex (language, "^[ \t]*[0-9]+[ \t]+([A-Z0-9][A-Z0-9-]*)\\.",
- "\\1", "g,struct,group items", "i");
+ "\\1", "g,group,group items", "i");
addTagRegex (language, "^[ \t]*([A-Z0-9][A-Z0-9-]*)\\.",
- "\\1", "p,macro,paragraphs", "i");
+ "\\1", "p,paragraph,paragraphs", "i");
addTagRegex (language, "^[ \t]*PROGRAM-ID\\.[ \t]+([A-Z0-9][A-Z0-9-]*)\\.",
- "\\1", "P,class,program ids", "i");
+ "\\1", "P,program,program ids", "i");
addTagRegex (language, "^[ \t]*([A-Z0-9][A-Z0-9-]*)[ \t]+SECTION\\.",
- "\\1", "n,namespace,sections", "i");
+ "\\1", "s,section,sections", "i");
}
extern parserDefinition* CobolParser (void)
Modified: tagmanager/ctags/css.c
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -19,8 +19,8 @@ typedef enum eCssKinds {
static kindOption CssKinds [] = {
{ TRUE, 'c', "class", "classes" },
- { TRUE, 's', "struct", "selectors" },
- { TRUE, 'v', "variable", "identities" }
+ { TRUE, 's', "selector", "selectors" },
+ { TRUE, 'i', "id", "identities" }
};
typedef enum {
Modified: tagmanager/ctags/erlang.c
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -32,8 +32,8 @@ static kindOption ErlangKinds[] = {
{TRUE, 'd', "macro", "macro definitions"},
{TRUE, 'f', "function", "functions"},
{TRUE, 'm', "module", "modules"},
- {TRUE, 'r', "struct", "record definitions"},
- {TRUE, 't', "typedef", "type definitions"},
+ {TRUE, 'r', "record", "record definitions"},
+ {TRUE, 't', "type", "type definitions"},
};
/*
Modified: tagmanager/ctags/fortran.c
16 lines changed, 8 insertions(+), 8 deletions(-)
===================================================================
@@ -215,22 +215,22 @@ static unsigned int contextual_fake_count = 0;
/* indexed by tagType */
static kindOption FortranKinds [TAG_COUNT] = {
- { TRUE, 'b', "block data", "block data"},
- { TRUE, 'c', "macro", "common blocks"},
+ { TRUE, 'b', "blockData", "block data"},
+ { TRUE, 'c', "common", "common blocks"},
{ TRUE, 'e', "entry", "entry points"},
{ TRUE, 'f', "function", "functions"},
{ TRUE, 'i', "interface", "interface contents, generic names, and operators"},
- { TRUE, 'k', "member", "type and structure components"},
+ { TRUE, 'k', "component", "type and structure components"},
{ TRUE, 'l', "label", "labels"},
{ FALSE, 'L', "local", "local, common block, and namelist variables"},
- { TRUE, 'm', "namespace", "modules"},
+ { TRUE, 'm', "module", "modules"},
{ TRUE, 'n', "namelist", "namelists"},
- { TRUE, 'p', "struct", "programs"},
- { TRUE, 's', "method", "subroutines"},
- { TRUE, 't', "class", "derived types and structures"},
+ { TRUE, 'p', "program", "programs"},
+ { TRUE, 's', "subroutine", "subroutines"},
+ { TRUE, 't', "type", "derived types and structures"},
{ TRUE, 'v', "variable", "program (global) and module variables"},
{ TRUE, 'E', "enum", "enumerations"},
- { TRUE, 'F', "enumerator", "enumeration values"},
+ { TRUE, 'N', "enumerator", "enumeration values"},
};
/* For efinitions of Fortran 77 with extensions:
Modified: tagmanager/ctags/go.c
10 lines changed, 5 insertions(+), 5 deletions(-)
===================================================================
@@ -93,11 +93,11 @@ typedef enum {
} goKind;
static kindOption GoKinds[] = {
- {TRUE, 'p', "namespace", "packages"},
- {TRUE, 'f', "function", "functions"},
- {TRUE, 'c', "macro", "constants"},
- {TRUE, 't', "typedef", "types"},
- {TRUE, 'v', "variable", "variables"},
+ {TRUE, 'p', "package", "packages"},
+ {TRUE, 'f', "func", "functions"},
+ {TRUE, 'c', "const", "constants"},
+ {TRUE, 't', "type", "types"},
+ {TRUE, 'v', "var", "variables"},
{TRUE, 's', "struct", "structs"},
{TRUE, 'i', "interface", "interfaces"},
{TRUE, 'm', "member", "struct members"}
Modified: tagmanager/ctags/html.c
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -28,7 +28,7 @@ static void installHtmlRegex (const langType language)
"[ \t]+name=\"?([^>\"]+)\"?"
POSSIBLE_ATTRIBUTES
"[ \t]*>",
- "\\2", "m,member,named anchors", "i");
+ "\\2", "a,anchor,named anchors", "i");
addTagRegex (language, "^[ \t]*function[ \t]*([A-Za-z0-9_]+)[ \t]*\\(",
"\\1", "f,function,JavaScript functions", NULL);
Modified: tagmanager/ctags/js.c
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -138,8 +138,8 @@ static kindOption JsKinds [] = {
{ TRUE, 'f', "function", "functions" },
{ TRUE, 'c', "class", "classes" },
{ TRUE, 'm', "method", "methods" },
- { TRUE, 'p', "member", "properties" },
- { TRUE, 'C', "macro", "constants" },
+ { TRUE, 'p', "property", "properties" },
+ { TRUE, 'C', "constant", "constants" },
{ TRUE, 'v', "variable", "global variables" }
};
Modified: tagmanager/ctags/json.c
12 lines changed, 6 insertions(+), 6 deletions(-)
===================================================================
@@ -69,12 +69,12 @@ typedef enum {
static langType Lang_json;
static kindOption JsonKinds [] = {
- { TRUE, 'o', "member", "objects" },
- { TRUE, 'a', "member", "arrays" },
- { TRUE, 'n', "member", "numbers" },
- { TRUE, 's', "member", "strings" },
- { TRUE, 'b', "member", "booleans" },
- { TRUE, 'z', "member", "nulls" }
+ { TRUE, 'o', "object", "objects" },
+ { TRUE, 'a', "array", "arrays" },
+ { TRUE, 'n', "number", "numbers" },
+ { TRUE, 's', "string", "strings" },
+ { TRUE, 'b', "boolean", "booleans" },
+ { TRUE, 'z', "null", "nulls" }
};
static tokenInfo *newToken (void)
Modified: tagmanager/ctags/make.c
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -30,7 +30,7 @@ typedef enum {
static kindOption MakeKinds [] = {
{ TRUE, 'm', "macro", "macros"},
- { TRUE, 't', "function", "targets"}
+ { TRUE, 't', "target", "targets"}
};
/*
Modified: tagmanager/ctags/parse.c
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -31,7 +31,7 @@
*/
static parserDefinitionFunc* BuiltInParsers[] = { PARSER_LIST };
parserDefinition** LanguageTable = NULL;
-static unsigned int LanguageCount = 0;
+unsigned int LanguageCount = 0;
tagEntryFunction TagEntryFunction = NULL;
void *TagEntryUserData = NULL;
Modified: tagmanager/ctags/parse.h
1 lines changed, 1 insertions(+), 0 deletions(-)
===================================================================
@@ -83,6 +83,7 @@ typedef void (*regexCallback) (const char *line, const regexMatch *matches, unsi
*/
extern parserDefinitionFunc PARSER_LIST;
extern parserDefinition** LanguageTable;
+extern unsigned int LanguageCount;
/* Legacy interface */
extern boolean includingDefineTags (void);
extern void processLegacyKindOption (const char *const parameter);
Modified: tagmanager/ctags/pascal.c
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -30,7 +30,7 @@ typedef enum {
static kindOption PascalKinds [] = {
{ TRUE, 'f', "function", "functions"},
- { TRUE, 'f', "function", "procedures"}
+ { TRUE, 'p', "procedure", "procedures"}
};
/*
Modified: tagmanager/ctags/perl.c
12 lines changed, 6 insertions(+), 6 deletions(-)
===================================================================
@@ -38,12 +38,12 @@ typedef enum {
} perlKind;
static kindOption PerlKinds [] = {
- { TRUE, 'e', "enum", "constants" },
- { TRUE, 'o', "other", "formats" },
- { TRUE, 'm', "macro", "labels" },
- { TRUE, 'p', "package", "packages" },
- { TRUE, 'f', "function", "subroutines" },
- { FALSE, 'p', "prototype", "subroutine declarations" },
+ { TRUE, 'c', "constant", "constants" },
+ { TRUE, 'f', "format", "formats" },
+ { TRUE, 'l', "label", "labels" },
+ { TRUE, 'p', "package", "packages" },
+ { TRUE, 's', "subroutine", "subroutines" },
+ { FALSE, 'd', "subroutineDeclaration", "subroutine declarations" },
};
/*
Modified: tagmanager/ctags/php.c
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -114,12 +114,12 @@ typedef enum {
static kindOption PhpKinds[COUNT_KIND] = {
{ TRUE, 'c', "class", "classes" },
- { TRUE, 'm', "macro", "constant definitions" },
+ { TRUE, 'd', "define", "constant definitions" },
{ TRUE, 'f', "function", "functions" },
{ TRUE, 'i', "interface", "interfaces" },
{ FALSE, 'l', "local", "local variables" },
{ TRUE, 'n', "namespace", "namespaces" },
- { TRUE, 's', "struct", "traits" },
+ { TRUE, 't', "trait", "traits" },
{ TRUE, 'v', "variable", "variables" }
};
Modified: tagmanager/ctags/python.c
6 lines changed, 2 insertions(+), 4 deletions(-)
===================================================================
@@ -31,11 +31,9 @@ typedef enum {
static kindOption PythonKinds[] = {
{TRUE, 'c', "class", "classes"},
{TRUE, 'f', "function", "functions"},
- {TRUE, 'm', "method", "class methods"},
+ {TRUE, 'm', "member", "class members"},
{TRUE, 'v', "variable", "variables"},
- /* 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 */
- {TRUE, 'x', "externvar", "imports"}
+ {TRUE, 'x', "unknown", "name referring a classe/variable/function/module defined in other module"}
};
typedef enum {
Modified: tagmanager/ctags/r.c
6 lines changed, 3 insertions(+), 3 deletions(-)
===================================================================
@@ -36,8 +36,8 @@ typedef enum {
static kindOption RKinds [KIND_COUNT] = {
{ TRUE, 'f', "function", "functions" },
- { TRUE, 's', "other", "libraries" },
- { TRUE, 's', "other", "sources" },
+ { TRUE, 'l', "library", "libraries" },
+ { TRUE, 's', "source", "sources" },
};
#endif
@@ -190,7 +190,7 @@ extern parserDefinition* RParser (void)
parserDefinition* const def = parserNew ("R");
#ifndef R_REGEX
def->kinds = RKinds;
- def->kindCount = 4;
+ def->kindCount = KIND_COUNT (RKinds);
#endif
def->extensions = extensions;
#ifndef R_REGEX
Modified: tagmanager/ctags/ruby.c
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -36,8 +36,8 @@ typedef enum {
static kindOption RubyKinds [] = {
{ TRUE, 'c', "class", "classes" },
{ TRUE, 'f', "method", "methods" },
- { TRUE, 'm', "namespace", "modules" },
- { TRUE, 'F', "member", "singleton methods" },
+ { TRUE, 'm', "module", "modules" },
+ { TRUE, 'F', "singletonMethod", "singleton methods" },
#if 0
/* Following two kinds are reserved. */
{ TRUE, 'd', "describe", "describes and contexts for Rspec" },
Modified: tagmanager/ctags/rust.c
4 lines changed, 2 insertions(+), 2 deletions(-)
===================================================================
@@ -47,10 +47,10 @@ typedef enum {
} RustKind;
static kindOption rustKinds[] = {
- {TRUE, 'n', "namespace", "module"},
+ {TRUE, 'n', "module", "module"},
{TRUE, 's', "struct", "structural type"},
{TRUE, 'i', "interface", "trait interface"},
- {TRUE, 'c', "class", "implementation"},
+ {TRUE, 'c', "implementation", "implementation"},
{TRUE, 'f', "function", "Function"},
{TRUE, 'g', "enum", "Enum"},
{TRUE, 't', "typedef", "Type Alias"},
Modified: tagmanager/ctags/sql.c
10 lines changed, 5 insertions(+), 5 deletions(-)
===================================================================
@@ -218,18 +218,18 @@ static kindOption SqlKinds [] = {
{ FALSE, 'l', "local", "local variables" },
{ TRUE, 'L', "label", "block label" },
{ TRUE, 'P', "package", "packages" },
- { TRUE, 'n', "namespace", "procedures" },
+ { TRUE, 'p', "procedure", "procedures" },
{ FALSE, 'r', "record", "records" },
{ TRUE, 's', "subtype", "subtypes" },
- { TRUE, 't', "class", "tables" },
- { TRUE, 'T', "macro", "triggers" },
+ { TRUE, 't', "table", "tables" },
+ { TRUE, 'T', "trigger", "triggers" },
{ TRUE, 'v', "variable", "variables" },
- { TRUE, 'i', "struct", "indexes" },
+ { TRUE, 'i', "index", "indexes" },
{ TRUE, 'e', "event", "events" },
{ TRUE, 'U', "publication", "publications" },
{ TRUE, 'R', "service", "services" },
{ TRUE, 'D', "domain", "domains" },
- { TRUE, 'm', "member", "views" },
+ { TRUE, 'V', "view", "views" },
{ TRUE, 'n', "synonym", "synonyms" },
{ TRUE, 'x', "mltable", "MobiLink Table Scripts" },
{ TRUE, 'y', "mlconn", "MobiLink Conn Scripts" },
Modified: tagmanager/ctags/tcl.c
6 lines changed, 3 insertions(+), 3 deletions(-)
===================================================================
@@ -27,9 +27,9 @@ typedef enum {
static kindOption TclKinds [] = {
{ TRUE, 'c', "class", "classes" },
- { TRUE, 'f', "member", "methods" },
- { TRUE, 'p', "function", "procedures" },
- { TRUE, 'm', "namespace", "modules" }
+ { TRUE, 'm', "method", "methods" },
+ { TRUE, 'p', "procedure", "procedures" },
+ { TRUE, 'n', "module", "modules" }
};
/*
Modified: tagmanager/ctags/verilog.c
14 lines changed, 7 insertions(+), 7 deletions(-)
===================================================================
@@ -58,14 +58,14 @@ static int Lang_verilog;
static jmp_buf Exception;
static kindOption VerilogKinds [] = {
- { TRUE, 'c', "variable", "constants (define, parameter, specparam)" },
- { TRUE, 'e', "typedef", "events" },
+ { TRUE, 'c', "constant", "constants (define, parameter, specparam)" },
+ { TRUE, 'e', "event", "events" },
{ TRUE, 'f', "function", "functions" },
- { TRUE, 'm', "class", "modules" },
- { TRUE, 'n', "variable", "net data types" },
- { TRUE, 'p', "variable", "ports" },
- { TRUE, 'r', "variable", "register data types" },
- { TRUE, 't', "function", "tasks" }
+ { TRUE, 'm', "module", "modules" },
+ { TRUE, 'n', "net", "net data types" },
+ { TRUE, 'p', "port", "ports" },
+ { TRUE, 'r', "register", "register data types" },
+ { TRUE, 't', "task", "tasks" }
};
static keywordAssoc VerilogKeywordTable [] = {
Modified: tagmanager/ctags/vhdl.c
2 lines changed, 1 insertions(+), 1 deletions(-)
===================================================================
@@ -79,7 +79,7 @@ static kindOption VhdlKinds [] = {
{ TRUE, 'o', "struct", "architecture" },
{ TRUE, 'u', "port", "ports" },
{ TRUE, 'b', "member", "blocks" },
- { TRUE, 'v', "typedef", "alias" }
+ { TRUE, 'A', "typedef", "alias" }
};
static keywordAssoc VhdlKeywordTable [] = {
Modified: tagmanager/src/Makefile.am
1 lines changed, 1 insertions(+), 0 deletions(-)
===================================================================
@@ -23,6 +23,7 @@ tagmanager_include_HEADERS = \
libtagmanager_la_SOURCES =\
tm_parser.h \
+ tm_parser.c \
tm_source_file.h \
tm_source_file.c \
tm_tag.h \
Modified: tagmanager/src/tm_ctags_wrappers.c
52 lines changed, 52 insertions(+), 0 deletions(-)
===================================================================
@@ -117,3 +117,55 @@ TMParserType tm_ctags_get_named_lang(const gchar *name)
}
+const gchar *tm_ctags_get_lang_kinds(TMParserType lang)
+{
+ guint i;
+ parserDefinition *def = LanguageTable[lang];
+ static gchar kinds[257];
+
+ for (i = 0; i < def->kindCount; i++)
+ kinds[i] = def->kinds[i].letter;
+ kinds[i] = '\0';
+
+ return kinds;
+}
+
+
+const gchar *tm_ctags_get_kind_name(gchar kind, TMParserType lang)
+{
+ guint i;
+ parserDefinition *def = LanguageTable[lang];
+
+ for (i = 0; i < def->kindCount; i++)
+ {
+ if (def->kinds[i].letter == kind)
+ return def->kinds[i].name;
+ }
+ return "unknown";
+}
+
+
+gchar tm_ctags_get_kind_from_name(const gchar *name, TMParserType lang)
+{
+ guint i;
+ parserDefinition *def = LanguageTable[lang];
+
+ for (i = 0; i < def->kindCount; i++)
+ {
+ if (g_strcmp0(def->kinds[i].name, name) == 0)
+ return def->kinds[i].letter;
+ }
+ return '-';
+}
+
+
+gboolean tm_ctags_is_using_regex_parser(TMParserType lang)
+{
+ return LanguageTable[lang]->regex;
+}
+
+
+guint tm_ctags_get_lang_count()
+{
+ return LanguageCount;
+}
Modified: tagmanager/src/tm_ctags_wrappers.h
10 lines changed, 10 insertions(+), 0 deletions(-)
===================================================================
@@ -44,6 +44,16 @@ 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);
+
+gboolean tm_ctags_is_using_regex_parser(TMParserType lang);
+
+guint tm_ctags_get_lang_count();
+
G_END_DECLS
#endif /* TM_CTAGS_WRAPPERS */
Modified: tagmanager/src/tm_parser.c
647 lines changed, 647 insertions(+), 0 deletions(-)
===================================================================
@@ -0,0 +1,647 @@
+/*
+ * tm_parser.c - this file is part of Geany, a fast and lightweight IDE
+ *
+ * Copyright 2016 Jiri Techet <techet(at)gmail(dot)com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "tm_parser.h"
+#include "tm_ctags_wrappers.h"
+
+#include <string.h>
+
+
+typedef struct
+{
+ const gchar kind;
+ TMTagType type;
+} TMParserMapEntry;
+
+
+static TMParserMapEntry c_map[] = {
+ {'c', tm_tag_class_t},
+ {'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},
+ {'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},
+};
+
+static TMParserMapEntry java_map[] = {
+ {'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},
+};
+
+static TMParserMapEntry makefile_map[] = {
+ {'m', tm_tag_macro_t},
+ {'t', tm_tag_function_t},
+};
+
+static TMParserMapEntry pascal_map[] = {
+ {'f', tm_tag_function_t},
+ {'p', tm_tag_function_t},
+};
+
+static TMParserMapEntry perl_map[] = {
+ {'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},
+};
+
+static TMParserMapEntry php_map[] = {
+ {'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},
+};
+
+static TMParserMapEntry python_map[] = {
+ {'c', tm_tag_class_t},
+ {'f', tm_tag_function_t},
+ {'m', tm_tag_method_t},
+ {'v', tm_tag_variable_t},
+ /* 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},
+};
+
+/* different parser than tex.c from universal-ctags */
+static TMParserMapEntry latex_map[] = {
+ {'f', tm_tag_function_t},
+ {'c', tm_tag_class_t},
+ {'m', tm_tag_member_t},
+ {'d', tm_tag_macro_t},
+ {'v', tm_tag_variable_t},
+ {'n', tm_tag_namespace_t},
+ {'s', tm_tag_struct_t},
+};
+
+static TMParserMapEntry asm_map[] = {
+ {'d', tm_tag_macro_t},
+ {'l', tm_tag_namespace_t},
+ {'m', tm_tag_function_t},
+ {'t', tm_tag_struct_t},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry conf_map[] = {
+ {'n', tm_tag_namespace_t},
+ {'m', tm_tag_macro_t},
+};
+
+static TMParserMapEntry sql_map[] = {
+ {'c', tm_tag_undef_t},
+ {'d', tm_tag_prototype_t},
+ {'f', tm_tag_function_t},
+ {'F', 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},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry docbook_map[] = {
+ {'f', tm_tag_function_t},
+ {'c', tm_tag_class_t},
+ {'m', tm_tag_member_t},
+ {'d', tm_tag_macro_t},
+ {'v', tm_tag_variable_t},
+ {'s', tm_tag_struct_t},
+};
+
+static TMParserMapEntry erlang_map[] = {
+ {'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},
+};
+
+static TMParserMapEntry css_map[] = {
+ {'c', tm_tag_class_t},
+ {'s', tm_tag_struct_t},
+ {'i', tm_tag_variable_t},
+};
+
+static TMParserMapEntry ruby_map[] = {
+ {'c', tm_tag_class_t},
+ {'f', tm_tag_method_t},
+ {'m', tm_tag_namespace_t},
+ {'F', tm_tag_member_t},
+};
+
+static TMParserMapEntry tcl_map[] = {
+ {'c', tm_tag_class_t},
+ {'m', tm_tag_member_t},
+ {'p', tm_tag_function_t},
+ {'n', tm_tag_namespace_t},
+};
+
+static TMParserMapEntry sh_map[] = {
+ {'f', tm_tag_function_t},
+};
+
+static TMParserMapEntry d_map[] = {
+ {'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},
+};
+
+static TMParserMapEntry diff_map[] = {
+ {'f', tm_tag_function_t},
+};
+
+/* different parser than in universal-ctags */
+static TMParserMapEntry vhdl_map[] = {
+ {'c', tm_tag_variable_t},
+ {'t', tm_tag_typedef_t},
+ {'v', tm_tag_variable_t},
+ {'a', tm_tag_undef_t},
+ {'s', tm_tag_variable_t},
+ {'f', tm_tag_function_t},
+ {'p', tm_tag_function_t},
+ {'k', tm_tag_member_t},
+ {'l', tm_tag_namespace_t},
+ {'m', tm_tag_member_t},
+ {'n', tm_tag_class_t},
+ {'o', tm_tag_struct_t},
+ {'u', tm_tag_undef_t},
+ {'b', tm_tag_member_t},
+ {'A', tm_tag_typedef_t},
+};
+
+static TMParserMapEntry lua_map[] = {
+ {'f', tm_tag_function_t},
+};
+
+static TMParserMapEntry javascript_map[] = {
+ {'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},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry haskell_map[] = {
+ {'t', tm_tag_typedef_t},
+ {'c', tm_tag_macro_t},
+ {'f', tm_tag_function_t},
+ {'m', tm_tag_namespace_t},
+};
+
+static TMParserMapEntry csharp_map[] = {
+ {'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},
+};
+
+static TMParserMapEntry freebasic_map[] = {
+ {'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},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry haxe_map[] = {
+ {'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},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry rest_map[] = {
+ {'n', tm_tag_namespace_t},
+ {'m', tm_tag_member_t},
+ {'d', tm_tag_macro_t},
+ {'v', tm_tag_variable_t},
+};
+
+static TMParserMapEntry html_map[] = {
+ {'a', tm_tag_member_t},
+ {'f', tm_tag_function_t},
+ {'n', tm_tag_namespace_t},
+ {'c', tm_tag_class_t},
+ {'v', tm_tag_variable_t},
+};
+
+static TMParserMapEntry f77_map[] = {
+ {'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},
+};
+
+/* different parser than in universal-ctags */
+static TMParserMapEntry matlab_map[] = {
+ {'f', tm_tag_function_t},
+ {'s', tm_tag_struct_t},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry vala_map[] = {
+ {'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},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry actionscript_map[] = {
+ {'f', tm_tag_function_t},
+ {'l', tm_tag_field_t},
+ {'v', tm_tag_variable_t},
+ {'m', tm_tag_macro_t},
+ {'c', tm_tag_class_t},
+ {'i', tm_tag_interface_t},
+ {'p', tm_tag_package_t},
+ {'o', tm_tag_other_t},
+ {'r', tm_tag_prototype_t},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry nsis_map[] = {
+ {'n', tm_tag_namespace_t},
+ {'f', tm_tag_function_t},
+ {'v', tm_tag_variable_t},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry markdown_map[] = {
+ {'v', tm_tag_variable_t},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry txt2tags_map[] = {
+ {'m', tm_tag_member_t},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry abc_map[] = {
+ {'m', tm_tag_member_t},
+ {'s', tm_tag_struct_t},
+};
+
+static TMParserMapEntry verilog_map[] = {
+ {'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},
+};
+
+static TMParserMapEntry r_map[] = {
+ {'f', tm_tag_function_t},
+ {'l', tm_tag_other_t},
+ {'s', tm_tag_other_t},
+};
+
+static TMParserMapEntry cobol_map[] = {
+ {'d', tm_tag_variable_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},
+};
+
+static TMParserMapEntry objc_map[] = {
+ {'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},
+ {'F', 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},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry asciidoc_map[] = {
+ {'n', tm_tag_namespace_t},
+ {'m', tm_tag_member_t},
+ {'d', tm_tag_macro_t},
+ {'v', tm_tag_variable_t},
+ {'s', tm_tag_struct_t},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry abaqus_map[] = {
+ {'c', tm_tag_class_t},
+ {'m', tm_tag_member_t},
+ {'n', tm_tag_interface_t},
+};
+
+static TMParserMapEntry rust_map[] = {
+ {'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},
+ {'F', tm_tag_method_t},
+};
+
+static TMParserMapEntry go_map[] = {
+ {'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},
+};
+
+static TMParserMapEntry json_map[] = {
+ {'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},
+};
+
+/* not in universal-ctags */
+static TMParserMapEntry powershell_map[] = {
+ {'f', tm_tag_function_t},
+ {'v', tm_tag_variable_t},
+};
+
+
+typedef struct
+{
+ TMParserMapEntry *entries;
+ guint size;
+} TMParserMap;
+
+#define MAP_ENTRY(map) {map, (sizeof(map)/sizeof(TMParserMapEntry))}
+
+/* keep in sync with TM_PARSER_* definitions in the header */
+static TMParserMap parser_map[] = {
+ MAP_ENTRY(c_map),
+ MAP_ENTRY(c_map), /* C++ - same as C */
+ MAP_ENTRY(java_map),
+ MAP_ENTRY(makefile_map),
+ MAP_ENTRY(pascal_map),
+ MAP_ENTRY(perl_map),
+ MAP_ENTRY(php_map),
+ MAP_ENTRY(python_map),
+ MAP_ENTRY(latex_map),
+ MAP_ENTRY(asm_map),
+ MAP_ENTRY(conf_map),
+ MAP_ENTRY(sql_map),
+ MAP_ENTRY(docbook_map),
+ MAP_ENTRY(erlang_map),
+ MAP_ENTRY(css_map),
+ MAP_ENTRY(ruby_map),
+ MAP_ENTRY(tcl_map),
+ MAP_ENTRY(sh_map),
+ MAP_ENTRY(d_map),
+ MAP_ENTRY(f77_map),
+ MAP_ENTRY(c_map), /* Ferite - same as C */
+ MAP_ENTRY(diff_map),
+ MAP_ENTRY(vhdl_map),
+ MAP_ENTRY(lua_map),
+ MAP_ENTRY(javascript_map),
+ MAP_ENTRY(haskell_map),
+ MAP_ENTRY(csharp_map),
+ MAP_ENTRY(freebasic_map),
+ MAP_ENTRY(haxe_map),
+ MAP_ENTRY(rest_map),
+ MAP_ENTRY(html_map),
+ MAP_ENTRY(f77_map),
+ MAP_ENTRY(c_map), /* GLSL - same as C */
+ MAP_ENTRY(matlab_map),
+ MAP_ENTRY(vala_map),
+ MAP_ENTRY(actionscript_map),
+ MAP_ENTRY(nsis_map),
+ MAP_ENTRY(markdown_map),
+ MAP_ENTRY(txt2tags_map),
+ MAP_ENTRY(abc_map),
+ MAP_ENTRY(verilog_map),
+ MAP_ENTRY(r_map),
+ MAP_ENTRY(cobol_map),
+ MAP_ENTRY(objc_map),
+ MAP_ENTRY(asciidoc_map),
+ MAP_ENTRY(abaqus_map),
+ MAP_ENTRY(rust_map),
+ MAP_ENTRY(go_map),
+ MAP_ENTRY(json_map),
+ MAP_ENTRY(php_map), /* Zephir - same as PHP */
+ MAP_ENTRY(powershell_map),
+};
+
+
+TMTagType tm_parser_get_tag_type(gchar kind, TMParserType lang)
+{
+ TMParserMap *map = &parser_map[lang];
+ guint i;
+
+ for (i = 0; i < map->size; i++)
+ {
+ TMParserMapEntry *entry = &map->entries[i];
+
+ if (entry->kind == kind)
+ return entry->type;
+ }
+ return tm_tag_undef_t;
+}
+
+
+gchar tm_parser_get_tag_kind(TMTagType type, TMParserType lang)
+{
+ TMParserMap *map = &parser_map[lang];
+ guint i;
+
+ for (i = 0; i < map->size; i++)
+ {
+ TMParserMapEntry *entry = &map->entries[i];
+
+ if (entry->type == type)
+ return entry->kind;
+ }
+ return '-';
+}
+
+
+void tm_parser_verify_type_mappings(void)
+{
+ gsize parser_map_size = sizeof(parser_map) / sizeof(TMParserMap);
+ TMParserType lang;
+
+ if (TM_PARSER_COUNT > tm_ctags_get_lang_count())
+ {
+ g_warning("More parsers defined in Geany than in ctags");
+ return;
+ }
+
+ if (parser_map_size != TM_PARSER_COUNT)
+ {
+ g_warning("Different number of parsers and tag type mappings");
+ return;
+ }
+
+ for (lang = 0; lang < TM_PARSER_COUNT; lang++)
+ {
+ const gchar *kinds = tm_ctags_get_lang_kinds(lang);
+ TMParserMap *map = &parser_map[lang];
+ gchar presence_map[256];
+ guint i;
+
+ /* TODO: check also regex parser mappings. At the moment there's no way
+ * to access regex parser definitions in ctags */
+ if (tm_ctags_is_using_regex_parser(lang))
+ continue;
+
+ if (map->size != strlen(kinds))
+ {
+ g_warning("Different number of tag types in TM (%d) and ctags (%d) for %s",
+ map->size, (int)strlen(kinds), tm_ctags_get_lang_name(lang));
+ continue;
+ }
+
+ memset(presence_map, 0, sizeof(presence_map));
+ for (i = 0; i < map->size; i++)
+ {
+ gboolean ctags_found = FALSE;
+ gboolean tm_found = FALSE;
+ guint j;
+
+ for (j = 0; j < map->size; j++)
+ {
+ /* check that for every type in TM there's a type in ctags */
+ if (map->entries[i].kind == kinds[j])
+ ctags_found = TRUE;
+ /* check that for every type in ctags there's a type in TM */
+ if (map->entries[j].kind == kinds[i])
+ tm_found = TRUE;
+ if (ctags_found && tm_found)
+ break;
+ }
+ if (!ctags_found)
+ g_warning("Tag type '%c' found in TM but not in ctags for %s",
+ map->entries[i].kind, tm_ctags_get_lang_name(lang));
+ if (!tm_found)
+ g_warning("Tag type '%c' found in ctags but not in TM for %s",
+ kinds[i], tm_ctags_get_lang_name(lang));
+
+ presence_map[map->entries[i].kind]++;
+ }
+
+ for (i = 0; i < sizeof(presence_map); i++)
+ {
+ if (presence_map[i] > 1)
+ g_warning("Duplicate tag type '%c' found for %s",
+ (gchar)i, tm_ctags_get_lang_name(lang));
+ }
+ }
+}
Modified: tagmanager/src/tm_parser.h
45 lines changed, 45 insertions(+), 0 deletions(-)
===================================================================
@@ -10,6 +10,42 @@
#ifndef TM_PARSER_H
#define TM_PARSER_H
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+/**
+ Types of tags. It is a bitmask so that multiple tag types can
+ be used simultaneously by 'OR'-ing them bitwise.
+ e.g. tm_tag_class_t | tm_tag_struct_t
+*/
+typedef enum
+{
+ tm_tag_undef_t = 0, /**< Unknown type */
+ tm_tag_class_t = 1, /**< Class declaration */
+ tm_tag_enum_t = 2, /**< Enum declaration */
+ tm_tag_enumerator_t = 4, /**< Enumerator value */
+ tm_tag_field_t = 8, /**< Field (Java only) */
+ tm_tag_function_t = 16, /**< Function definition */
+ tm_tag_interface_t = 32, /**< Interface (Java only) */
+ tm_tag_member_t = 64, /**< Member variable of class/struct */
+ tm_tag_method_t = 128, /**< Class method (Java only) */
+ tm_tag_namespace_t = 256, /**< Namespace declaration */
+ tm_tag_package_t = 512, /**< Package (Java only) */
+ tm_tag_prototype_t = 1024, /**< Function prototype */
+ tm_tag_struct_t = 2048, /**< Struct declaration */
+ tm_tag_typedef_t = 4096, /**< Typedef */
+ tm_tag_union_t = 8192, /**< Union */
+ tm_tag_variable_t = 16384, /**< Variable */
+ tm_tag_externvar_t = 32768, /**< Extern or forward declaration */
+ tm_tag_macro_t = 65536, /**< Macro (without arguments) */
+ tm_tag_macro_with_arg_t = 131072, /**< Parameterized macro */
+ tm_tag_file_t = 262144, /**< File (Pseudo tag) - obsolete */
+ tm_tag_other_t = 524288, /**< Other (non C/C++/Java tag) */
+ tm_tag_max_t = 1048575 /**< Maximum value of TMTagType */
+} TMTagType;
+
+
/** @gironly
* A integral type which can hold known parser type IDs
**/
@@ -76,6 +112,15 @@ enum
TM_PARSER_COUNT
};
+
+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);
+
#endif /* GEANY_PRIVATE */
+G_END_DECLS
+
#endif /* TM_PARSER_H */
Modified: tagmanager/src/tm_source_file.c
103 lines changed, 6 insertions(+), 97 deletions(-)
===================================================================
@@ -66,48 +66,6 @@ enum
TA_POINTER
};
-static const char *s_tag_type_names[] = {
- "class", /* classes */
- "enum", /* enumeration names */
- "enumerator", /* enumerators (values inside an enumeration) */
- "externvar", /* external variable declarations */
- "field", /* fields */
- "function", /* function definitions */
- "interface", /* interfaces */
- "macro", /* macro definitions */
- "member", /* class, struct, and union members */
- "method", /* methods */
- "namespace", /* namespaces */
- "package", /* packages */
- "prototype", /* function prototypes */
- "struct", /* structure names */
- "typedef", /* typedefs */
- "union", /* union names */
- "variable", /* variable definitions */
- "other" /* Other tag type (non C/C++/Java) */
-};
-
-static TMTagType s_tag_types[] = {
- tm_tag_class_t,
- tm_tag_enum_t,
- tm_tag_enumerator_t,
- tm_tag_externvar_t,
- tm_tag_field_t,
- tm_tag_function_t,
- tm_tag_interface_t,
- tm_tag_macro_t,
- tm_tag_member_t,
- tm_tag_method_t,
- tm_tag_namespace_t,
- tm_tag_package_t,
- tm_tag_prototype_t,
- tm_tag_struct_t,
- tm_tag_typedef_t,
- tm_tag_union_t,
- tm_tag_variable_t,
- tm_tag_other_t
-};
-
#define SOURCE_FILE_NEW(S) ((S) = g_slice_new(TMSourceFilePriv))
#define SOURCE_FILE_FREE(S) g_slice_free(TMSourceFilePriv, (TMSourceFilePriv *) S)
@@ -174,28 +132,6 @@ gchar *tm_get_real_path(const gchar *file_name)
return NULL;
}
-static TMTagType get_tag_type(const char *tag_name)
-{
- unsigned int i;
- int cmp;
- g_return_val_if_fail(tag_name, 0);
- for (i=0; i < sizeof(s_tag_type_names)/sizeof(char *); ++i)
- {
- cmp = strcmp(tag_name, s_tag_type_names[i]);
- if (0 == cmp)
- return s_tag_types[i];
- else if (cmp < 0)
- break;
- }
- /* other is not checked above as it is last, not sorted alphabetically */
- if (strcmp(tag_name, "other") == 0)
- return tm_tag_other_t;
-#ifdef TM_DEBUG
- fprintf(stderr, "Unknown tag type %s\n", tag_name);
-#endif
- return tm_tag_undef_t;
-}
-
static char get_tag_impl(const char *impl)
{
if ((0 == strcmp("virtual", impl))
@@ -244,7 +180,7 @@ static gboolean init_tag(TMTag *tag, TMSourceFile *file, const tagEntryInfo *tag
if (!tag_entry)
return FALSE;
- type = get_tag_type(tag_entry->kindName);
+ type = tm_parser_get_tag_type(tag_entry->kind, file->lang);
if (!tag_entry->name || type == tm_tag_undef_t)
return FALSE;
@@ -408,7 +344,7 @@ static gboolean init_tag_from_file_alt(TMTag *tag, TMSourceFile *file, FILE *fp)
/*
CTags tag file format (http://ctags.sourceforge.net/FORMAT)
*/
-static gboolean init_tag_from_file_ctags(TMTag *tag, TMSourceFile *file, FILE *fp)
+static gboolean init_tag_from_file_ctags(TMTag *tag, TMSourceFile *file, FILE *fp, TMParserType lang)
{
gchar buf[BUFSIZ];
gchar *p, *tab;
@@ -482,37 +418,9 @@ 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 = get_tag_type(kind);
+ tag->type = tm_parser_get_tag_type(tm_ctags_get_kind_from_name(kind, lang), lang);
else
- {
- switch (*kind)
- {
- case 'c': tag->type = tm_tag_class_t; break;
- case 'd': tag->type = tm_tag_macro_t; break;
- case 'e': tag->type = tm_tag_enumerator_t; break;
- case 'F': tag->type = tm_tag_other_t; break; /* Obsolete */
- case 'f': tag->type = tm_tag_function_t; break;
- case 'g': tag->type = tm_tag_enum_t; break;
- case 'I': tag->type = tm_tag_class_t; break;
- case 'i': tag->type = tm_tag_interface_t; break;
- case 'l': tag->type = tm_tag_variable_t; break;
- case 'M': tag->type = tm_tag_macro_t; break;
- case 'm': tag->type = tm_tag_member_t; break;
- case 'n': tag->type = tm_tag_namespace_t; break;
- case 'P': tag->type = tm_tag_package_t; break;
- case 'p': tag->type = tm_tag_prototype_t; break;
- case 's': tag->type = tm_tag_struct_t; break;
- case 't': tag->type = tm_tag_typedef_t; break;
- case 'u': tag->type = tm_tag_union_t; break;
- case 'v': tag->type = tm_tag_variable_t; break;
- case 'x': tag->type = tm_tag_externvar_t; break;
- default:
-#ifdef TM_DEBUG
- g_warning("Unknown tag kind %c", *kind);
-#endif
- tag->type = tm_tag_other_t; break;
- }
- }
+ tag->type = tm_parser_get_tag_type(*kind, lang);
}
else if (0 == strcmp(key, "inherits")) /* comma-separated list of classes this class inherits from */
{
@@ -562,7 +470,7 @@ static TMTag *new_tag_from_tags_file(TMSourceFile *file, FILE *fp, TMParserType
result = init_tag_from_file_alt(tag, file, fp);
break;
case TM_FILE_FORMAT_CTAGS:
- result = init_tag_from_file_ctags(tag, file, fp);
+ result = init_tag_from_file_ctags(tag, file, fp, mode);
break;
}
@@ -756,6 +664,7 @@ static gboolean tm_source_file_tags(const tagEntryInfo *const tag,
void tm_source_file_ctags_init()
{
tm_ctags_init();
+ tm_parser_verify_type_mappings();
}
/* Initializes a TMSourceFile structure from a file name. */
Modified: tagmanager/src/tm_tag.c
48 lines changed, 5 insertions(+), 43 deletions(-)
===================================================================
@@ -12,6 +12,7 @@
#include <glib-object.h>
#include "tm_tag.h"
+#include "tm_ctags_wrappers.h"
#define TAG_NEW(T) ((T) = g_slice_new0(TMTag))
@@ -728,58 +729,19 @@ gboolean tm_tag_langs_compatible(TMParserType lang, TMParserType other)
const char *tm_tag_type_name(const TMTag *tag)
{
g_return_val_if_fail(tag, NULL);
- switch(tag->type)
- {
- case tm_tag_class_t: return "class";
- case tm_tag_enum_t: return "enum";
- case tm_tag_enumerator_t: return "enumval";
- case tm_tag_field_t: return "field";
- case tm_tag_function_t: return "function";
- case tm_tag_interface_t: return "interface";
- case tm_tag_member_t: return "member";
- case tm_tag_method_t: return "method";
- case tm_tag_namespace_t: return "namespace";
- case tm_tag_package_t: return "package";
- case tm_tag_prototype_t: return "prototype";
- case tm_tag_struct_t: return "struct";
- case tm_tag_typedef_t: return "typedef";
- case tm_tag_union_t: return "union";
- case tm_tag_variable_t: return "variable";
- case tm_tag_externvar_t: return "extern";
- case tm_tag_macro_t: return "define";
- case tm_tag_macro_with_arg_t: return "macro";
- default: return NULL;
- }
- return NULL;
+
+ return tm_ctags_get_kind_name(tm_parser_get_tag_kind(tag->type, tag->lang), tag->lang);
}
/*
Returns the TMTagType given the name of the type. Reverse of tm_tag_type_name.
@param tag_name Name of the tag type
*/
-TMTagType tm_tag_name_type(const char* tag_name)
+TMTagType tm_tag_name_type(const char* tag_name, TMParserType lang)
{
g_return_val_if_fail(tag_name, tm_tag_undef_t);
- if (strcmp(tag_name, "class") == 0) return tm_tag_class_t;
- else if (strcmp(tag_name, "enum") == 0) return tm_tag_enum_t;
- else if (strcmp(tag_name, "enumval") == 0) return tm_tag_enumerator_t;
- else if (strcmp(tag_name, "field") == 0) return tm_tag_field_t;
- else if (strcmp(tag_name, "function") == 0) return tm_tag_function_t;
- else if (strcmp(tag_name, "interface") == 0) return tm_tag_interface_t;
- else if (strcmp(tag_name, "member") == 0) return tm_tag_member_t;
- else if (strcmp(tag_name, "method") == 0) return tm_tag_method_t;
- else if (strcmp(tag_name, "namespace") == 0) return tm_tag_namespace_t;
- else if (strcmp(tag_name, "package") == 0) return tm_tag_package_t;
- else if (strcmp(tag_name, "prototype") == 0) return tm_tag_prototype_t;
- else if (strcmp(tag_name, "struct") == 0) return tm_tag_struct_t;
- else if (strcmp(tag_name, "typedef") == 0) return tm_tag_typedef_t;
- else if (strcmp(tag_name, "union") == 0) return tm_tag_union_t;
- else if (strcmp(tag_name, "variable") == 0) return tm_tag_variable_t;
- else if (strcmp(tag_name, "extern") == 0) return tm_tag_externvar_t;
- else if (strcmp(tag_name, "define") == 0) return tm_tag_macro_t;
- else if (strcmp(tag_name, "macro") == 0) return tm_tag_macro_with_arg_t;
- else return tm_tag_undef_t;
+ return tm_parser_get_tag_type(tm_ctags_get_kind_from_name(tag_name, lang), lang);
}
static const char *tm_tag_impl_name(TMTag *tag)
Modified: tagmanager/src/tm_tag.h
32 lines changed, 1 insertions(+), 31 deletions(-)
===================================================================
@@ -30,6 +30,7 @@
*/
#include "tm_source_file.h"
+#include "tm_parser.h"
#include <glib-object.h>
G_BEGIN_DECLS
@@ -38,37 +39,6 @@ G_BEGIN_DECLS
#define TM_TAG(tag) ((TMTag *) tag)
/**
- Types of tags. It is a bitmask so that multiple tag types can
- be used simultaneously by 'OR'-ing them bitwise.
- e.g. tm_tag_class_t | tm_tag_struct_t
-*/
-typedef enum
-{
- tm_tag_undef_t = 0, /**< Unknown type */
- tm_tag_class_t = 1, /**< Class declaration */
- tm_tag_enum_t = 2, /**< Enum declaration */
- tm_tag_enumerator_t = 4, /**< Enumerator value */
- tm_tag_field_t = 8, /**< Field (Java only) */
- tm_tag_function_t = 16, /**< Function definition */
- tm_tag_interface_t = 32, /**< Interface (Java only) */
- tm_tag_member_t = 64, /**< Member variable of class/struct */
- tm_tag_method_t = 128, /**< Class method (Java only) */
- tm_tag_namespace_t = 256, /**< Namespace declaration */
- tm_tag_package_t = 512, /**< Package (Java only) */
- tm_tag_prototype_t = 1024, /**< Function prototype */
- tm_tag_struct_t = 2048, /**< Struct declaration */
- tm_tag_typedef_t = 4096, /**< Typedef */
- tm_tag_union_t = 8192, /**< Union */
- tm_tag_variable_t = 16384, /**< Variable */
- tm_tag_externvar_t = 32768, /**< Extern or forward declaration */
- tm_tag_macro_t = 65536, /**< Macro (without arguments) */
- tm_tag_macro_with_arg_t = 131072, /**< Parameterized macro */
- tm_tag_file_t = 262144, /**< File (Pseudo tag) - obsolete */
- tm_tag_other_t = 524288, /**< Other (non C/C++/Java tag) */
- tm_tag_max_t = 1048575 /**< Maximum value of TMTagType */
-} TMTagType;
-
-/**
Tag Attributes. Note that some attributes are available to file
pseudotags only. Attributes are useful for specifying as arguments
to the builtin sort and dedup functions, and during printing or writing
--------------
This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).
More information about the Commits
mailing list