Mercurial > projects > doodle
diff nobuild/ctags.patch @ 137:9a9dcae45e08
Misc support file changes
author | David Bryant <bagnose@gmail.com> |
---|---|
date | Sun, 30 Sep 2012 15:25:11 +0930 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/nobuild/ctags.patch Sun Sep 30 15:25:11 2012 +0930 @@ -0,0 +1,711 @@ +diff -u ctags-5.8.orig//c.c ctags-5.8//c.c +--- ctags-5.8.orig//c.c 2009-07-05 06:02:43.000000000 +0200 ++++ ctags-5.8//c.c 2010-05-22 02:40:25.657027772 +0200 +@@ -59,7 +59,7 @@ + */ + typedef enum eKeywordId { + KEYWORD_NONE = -1, +- KEYWORD_ATTRIBUTE, KEYWORD_ABSTRACT, ++ KEYWORD_ALIAS, KEYWORD_ATTRIBUTE, KEYWORD_ABSTRACT, + KEYWORD_BOOLEAN, KEYWORD_BYTE, KEYWORD_BAD_STATE, KEYWORD_BAD_TRANS, + KEYWORD_BIND, KEYWORD_BIND_VAR, KEYWORD_BIT, + KEYWORD_CASE, KEYWORD_CATCH, KEYWORD_CHAR, KEYWORD_CLASS, KEYWORD_CONST, +@@ -91,7 +91,19 @@ + KEYWORD_UINT, KEYWORD_ULONG, KEYWORD_UNION, KEYWORD_UNSIGNED, KEYWORD_USHORT, + KEYWORD_USING, + KEYWORD_VIRTUAL, KEYWORD_VOID, KEYWORD_VOLATILE, +- KEYWORD_WCHAR_T, KEYWORD_WHILE ++ KEYWORD_WCHAR_T, KEYWORD_WHILE, ++ KEYWORD_ALIGN, KEYWORD_ASM, KEYWORD_ASSERT, KEYWORD_AUTO, ++ KEYWORD_BODY, KEYWORD_BOOL, KEYWORD_BREAK, KEYWORD_CAST, ++ KEYWORD_CDOUBLE, KEYWORD_CENT, KEYWORD_CFLOAT, KEYWORD_CONTINUE, ++ KEYWORD_CREAL, KEYWORD_DCHAR, KEYWORD_DEBUG, ++ KEYWORD_DEPRECATED, KEYWORD_EXPORT, KEYWORD_FALSE, KEYWORD_FINALLY, ++ KEYWORD_FOREACH_REVERSE, KEYWORD_IDOUBLE, KEYWORD_IFLOAT, ++ KEYWORD_IN, KEYWORD_INVARIANT, KEYWORD_IREAL, KEYWORD_IS, ++ KEYWORD_LAZY, KEYWORD_MIXIN, KEYWORD_MODULE, KEYWORD_NULL, ++ KEYWORD_OUT, KEYWORD_PRAGMA, KEYWORD_REAL, KEYWORD_SCOPE, ++ KEYWORD_SUPER, KEYWORD_TRUE, KEYWORD_TYPEID, KEYWORD_TYPEOF, ++ KEYWORD_UBYTE, KEYWORD_UCENT, KEYWORD_UNITTEST, KEYWORD_VERSION, ++ KEYWORD_WCHAR, KEYWORD_WITH + } keywordId; + + /* Used to determine whether keyword is valid for the current language and +@@ -100,7 +112,7 @@ + typedef struct sKeywordDesc { + const char *name; + keywordId id; +- short isValid [5]; /* indicates languages for which kw is valid */ ++ short isValid [6]; /* indicates languages for which kw is valid */ + } keywordDesc; + + /* Used for reporting the type of object parsed by nextToken (). +@@ -115,7 +127,7 @@ + TOKEN_DOUBLE_COLON, /* double colon indicates nested-name-specifier */ + TOKEN_KEYWORD, + TOKEN_NAME, /* an unknown name */ +- TOKEN_PACKAGE, /* a Java package name */ ++ TOKEN_PACKAGE, /* a Java package name / a D module name */ + TOKEN_PAREN_NAME, /* a single name in parentheses */ + TOKEN_SEMICOLON, /* the semicolon character */ + TOKEN_SPEC, /* a storage class specifier, qualifier, type, etc. */ +@@ -140,15 +152,19 @@ + DECL_ENUM, + DECL_EVENT, + DECL_FUNCTION, ++ DECL_FUNCTION_TEMPLATE, + DECL_IGNORE, /* non-taggable "declaration" */ + DECL_INTERFACE, ++ DECL_MIXIN, + DECL_NAMESPACE, + DECL_NOMANGLE, /* C++ name demangling block */ + DECL_PACKAGE, + DECL_PROGRAM, /* Vera program */ + DECL_STRUCT, + DECL_TASK, /* Vera task */ ++ DECL_TEMPLATE, + DECL_UNION, ++ DECL_VERSION, /* D conditional compile */ + DECL_COUNT + } declType; + +@@ -218,10 +234,12 @@ + TAG_EVENT, /* event */ + TAG_FIELD, /* field (Java) */ + TAG_FUNCTION, /* function definition */ ++ TAG_FUNCTION_TEMPLATE, /* D function template */ + TAG_INTERFACE, /* interface declaration */ + TAG_LOCAL, /* local variable definition */ + TAG_MEMBER, /* structure, class or interface member */ + TAG_METHOD, /* method declaration */ ++ TAG_MIXIN, /* D mixin */ + TAG_NAMESPACE, /* namespace name */ + TAG_PACKAGE, /* package name */ + TAG_PROGRAM, /* program name */ +@@ -230,9 +248,11 @@ + TAG_STRUCT, /* structure name */ + TAG_TASK, /* task name */ + TAG_TYPEDEF, /* typedef name */ ++ TAG_TEMPLATE, /* d template name */ + TAG_UNION, /* union name */ + TAG_VARIABLE, /* variable definition */ + TAG_EXTERN_VAR, /* external variable declaration */ ++ TAG_VERSION, /* conditional template compilation */ + TAG_COUNT /* must be last */ + } tagType; + +@@ -255,6 +275,7 @@ + static langType Lang_c; + static langType Lang_cpp; + static langType Lang_csharp; ++static langType Lang_d; + static langType Lang_java; + static langType Lang_vera; + static vString *Signature; +@@ -267,9 +288,9 @@ + typedef enum { + CK_UNDEFINED = -1, + CK_CLASS, CK_DEFINE, CK_ENUMERATOR, CK_FUNCTION, +- CK_ENUMERATION, CK_LOCAL, CK_MEMBER, CK_NAMESPACE, CK_PROTOTYPE, +- CK_STRUCT, CK_TYPEDEF, CK_UNION, CK_VARIABLE, +- CK_EXTERN_VARIABLE ++ CK_ENUMERATION, CK_LOCAL, CK_MEMBER, CK_MODULE, CK_NAMESPACE, CK_PROTOTYPE, ++ CK_STRUCT, CK_TYPEDEF, CK_TEMPLATE, CK_UNION, CK_VARIABLE, ++ CK_EXTERN_VARIABLE, CK_MIXIN, CK_VERSION + } cKind; + + static kindOption CKinds [] = { +@@ -280,13 +301,17 @@ + { TRUE, 'g', "enum", "enumeration names"}, + { FALSE, 'l', "local", "local variables"}, + { TRUE, 'm', "member", "class, struct, and union members"}, ++ { TRUE, 'M', "module", "module"}, + { TRUE, 'n', "namespace", "namespaces"}, + { FALSE, 'p', "prototype", "function prototypes"}, + { TRUE, 's', "struct", "structure names"}, + { TRUE, 't', "typedef", "typedefs"}, ++ { TRUE, 'T', "template", "templates"}, + { TRUE, 'u', "union", "union names"}, + { TRUE, 'v', "variable", "variable definitions"}, + { FALSE, 'x', "externvar", "external and forward variable declarations"}, ++ { TRUE, 'X', "mixin", "mixin"}, ++ { TRUE, 'V', "version", "conditional compilation"} + }; + + typedef enum { +@@ -356,110 +381,155 @@ + }; + + static const keywordDesc KeywordTable [] = { +- /* C++ */ +- /* ANSI C | C# Java */ +- /* | | | | Vera */ +- /* keyword keyword ID | | | | | */ +- { "__attribute__", KEYWORD_ATTRIBUTE, { 1, 1, 1, 0, 0 } }, +- { "abstract", KEYWORD_ABSTRACT, { 0, 0, 1, 1, 0 } }, +- { "bad_state", KEYWORD_BAD_STATE, { 0, 0, 0, 0, 1 } }, +- { "bad_trans", KEYWORD_BAD_TRANS, { 0, 0, 0, 0, 1 } }, +- { "bind", KEYWORD_BIND, { 0, 0, 0, 0, 1 } }, +- { "bind_var", KEYWORD_BIND_VAR, { 0, 0, 0, 0, 1 } }, +- { "bit", KEYWORD_BIT, { 0, 0, 0, 0, 1 } }, +- { "boolean", KEYWORD_BOOLEAN, { 0, 0, 0, 1, 0 } }, +- { "byte", KEYWORD_BYTE, { 0, 0, 0, 1, 0 } }, +- { "case", KEYWORD_CASE, { 1, 1, 1, 1, 0 } }, +- { "catch", KEYWORD_CATCH, { 0, 1, 1, 0, 0 } }, +- { "char", KEYWORD_CHAR, { 1, 1, 1, 1, 0 } }, +- { "class", KEYWORD_CLASS, { 0, 1, 1, 1, 1 } }, +- { "const", KEYWORD_CONST, { 1, 1, 1, 1, 0 } }, +- { "constraint", KEYWORD_CONSTRAINT, { 0, 0, 0, 0, 1 } }, +- { "coverage_block", KEYWORD_COVERAGE_BLOCK, { 0, 0, 0, 0, 1 } }, +- { "coverage_def", KEYWORD_COVERAGE_DEF, { 0, 0, 0, 0, 1 } }, +- { "do", KEYWORD_DO, { 1, 1, 1, 1, 0 } }, +- { "default", KEYWORD_DEFAULT, { 1, 1, 1, 1, 0 } }, +- { "delegate", KEYWORD_DELEGATE, { 0, 0, 1, 0, 0 } }, +- { "delete", KEYWORD_DELETE, { 0, 1, 0, 0, 0 } }, +- { "double", KEYWORD_DOUBLE, { 1, 1, 1, 1, 0 } }, +- { "else", KEYWORD_ELSE, { 1, 1, 1, 1, 0 } }, +- { "enum", KEYWORD_ENUM, { 1, 1, 1, 1, 1 } }, +- { "event", KEYWORD_EVENT, { 0, 0, 1, 0, 1 } }, +- { "explicit", KEYWORD_EXPLICIT, { 0, 1, 1, 0, 0 } }, +- { "extends", KEYWORD_EXTENDS, { 0, 0, 0, 1, 1 } }, +- { "extern", KEYWORD_EXTERN, { 1, 1, 1, 0, 1 } }, +- { "final", KEYWORD_FINAL, { 0, 0, 0, 1, 0 } }, +- { "float", KEYWORD_FLOAT, { 1, 1, 1, 1, 0 } }, +- { "for", KEYWORD_FOR, { 1, 1, 1, 1, 0 } }, +- { "foreach", KEYWORD_FOREACH, { 0, 0, 1, 0, 0 } }, +- { "friend", KEYWORD_FRIEND, { 0, 1, 0, 0, 0 } }, +- { "function", KEYWORD_FUNCTION, { 0, 0, 0, 0, 1 } }, +- { "goto", KEYWORD_GOTO, { 1, 1, 1, 1, 0 } }, +- { "if", KEYWORD_IF, { 1, 1, 1, 1, 0 } }, +- { "implements", KEYWORD_IMPLEMENTS, { 0, 0, 0, 1, 0 } }, +- { "import", KEYWORD_IMPORT, { 0, 0, 0, 1, 0 } }, +- { "inline", KEYWORD_INLINE, { 0, 1, 0, 0, 0 } }, +- { "inout", KEYWORD_INOUT, { 0, 0, 0, 0, 1 } }, +- { "input", KEYWORD_INPUT, { 0, 0, 0, 0, 1 } }, +- { "int", KEYWORD_INT, { 1, 1, 1, 1, 0 } }, +- { "integer", KEYWORD_INTEGER, { 0, 0, 0, 0, 1 } }, +- { "interface", KEYWORD_INTERFACE, { 0, 0, 1, 1, 1 } }, +- { "internal", KEYWORD_INTERNAL, { 0, 0, 1, 0, 0 } }, +- { "local", KEYWORD_LOCAL, { 0, 0, 0, 0, 1 } }, +- { "long", KEYWORD_LONG, { 1, 1, 1, 1, 0 } }, +- { "m_bad_state", KEYWORD_M_BAD_STATE, { 0, 0, 0, 0, 1 } }, +- { "m_bad_trans", KEYWORD_M_BAD_TRANS, { 0, 0, 0, 0, 1 } }, +- { "m_state", KEYWORD_M_STATE, { 0, 0, 0, 0, 1 } }, +- { "m_trans", KEYWORD_M_TRANS, { 0, 0, 0, 0, 1 } }, +- { "mutable", KEYWORD_MUTABLE, { 0, 1, 0, 0, 0 } }, +- { "namespace", KEYWORD_NAMESPACE, { 0, 1, 1, 0, 0 } }, +- { "native", KEYWORD_NATIVE, { 0, 0, 0, 1, 0 } }, +- { "new", KEYWORD_NEW, { 0, 1, 1, 1, 0 } }, +- { "newcov", KEYWORD_NEWCOV, { 0, 0, 0, 0, 1 } }, +- { "operator", KEYWORD_OPERATOR, { 0, 1, 1, 0, 0 } }, +- { "output", KEYWORD_OUTPUT, { 0, 0, 0, 0, 1 } }, +- { "overload", KEYWORD_OVERLOAD, { 0, 1, 0, 0, 0 } }, +- { "override", KEYWORD_OVERRIDE, { 0, 0, 1, 0, 0 } }, +- { "package", KEYWORD_PACKAGE, { 0, 0, 0, 1, 0 } }, +- { "packed", KEYWORD_PACKED, { 0, 0, 0, 0, 1 } }, +- { "port", KEYWORD_PORT, { 0, 0, 0, 0, 1 } }, +- { "private", KEYWORD_PRIVATE, { 0, 1, 1, 1, 0 } }, +- { "program", KEYWORD_PROGRAM, { 0, 0, 0, 0, 1 } }, +- { "protected", KEYWORD_PROTECTED, { 0, 1, 1, 1, 1 } }, +- { "public", KEYWORD_PUBLIC, { 0, 1, 1, 1, 1 } }, +- { "register", KEYWORD_REGISTER, { 1, 1, 0, 0, 0 } }, +- { "return", KEYWORD_RETURN, { 1, 1, 1, 1, 0 } }, +- { "shadow", KEYWORD_SHADOW, { 0, 0, 0, 0, 1 } }, +- { "short", KEYWORD_SHORT, { 1, 1, 1, 1, 0 } }, +- { "signed", KEYWORD_SIGNED, { 1, 1, 0, 0, 0 } }, +- { "state", KEYWORD_STATE, { 0, 0, 0, 0, 1 } }, +- { "static", KEYWORD_STATIC, { 1, 1, 1, 1, 1 } }, +- { "string", KEYWORD_STRING, { 0, 0, 1, 0, 1 } }, +- { "struct", KEYWORD_STRUCT, { 1, 1, 1, 0, 0 } }, +- { "switch", KEYWORD_SWITCH, { 1, 1, 1, 1, 0 } }, +- { "synchronized", KEYWORD_SYNCHRONIZED, { 0, 0, 0, 1, 0 } }, +- { "task", KEYWORD_TASK, { 0, 0, 0, 0, 1 } }, +- { "template", KEYWORD_TEMPLATE, { 0, 1, 0, 0, 0 } }, +- { "this", KEYWORD_THIS, { 0, 1, 1, 1, 0 } }, +- { "throw", KEYWORD_THROW, { 0, 1, 1, 1, 0 } }, +- { "throws", KEYWORD_THROWS, { 0, 0, 0, 1, 0 } }, +- { "trans", KEYWORD_TRANS, { 0, 0, 0, 0, 1 } }, +- { "transition", KEYWORD_TRANSITION, { 0, 0, 0, 0, 1 } }, +- { "transient", KEYWORD_TRANSIENT, { 0, 0, 0, 1, 0 } }, +- { "try", KEYWORD_TRY, { 0, 1, 1, 0, 0 } }, +- { "typedef", KEYWORD_TYPEDEF, { 1, 1, 1, 0, 1 } }, +- { "typename", KEYWORD_TYPENAME, { 0, 1, 0, 0, 0 } }, +- { "uint", KEYWORD_UINT, { 0, 0, 1, 0, 0 } }, +- { "ulong", KEYWORD_ULONG, { 0, 0, 1, 0, 0 } }, +- { "union", KEYWORD_UNION, { 1, 1, 0, 0, 0 } }, +- { "unsigned", KEYWORD_UNSIGNED, { 1, 1, 1, 0, 0 } }, +- { "ushort", KEYWORD_USHORT, { 0, 0, 1, 0, 0 } }, +- { "using", KEYWORD_USING, { 0, 1, 1, 0, 0 } }, +- { "virtual", KEYWORD_VIRTUAL, { 0, 1, 1, 0, 1 } }, +- { "void", KEYWORD_VOID, { 1, 1, 1, 1, 1 } }, +- { "volatile", KEYWORD_VOLATILE, { 1, 1, 1, 1, 0 } }, +- { "wchar_t", KEYWORD_WCHAR_T, { 1, 1, 1, 0, 0 } }, +- { "while", KEYWORD_WHILE, { 1, 1, 1, 1, 0 } } ++ /* C++ D */ ++ /* ANSI C | C# | Java */ ++ /* | | | | | Vera */ ++ /* keyword keyword ID | | | | | | */ ++ { "__attribute__", KEYWORD_ATTRIBUTE, { 1, 1, 1, 1, 0, 0 } }, ++ { "abstract", KEYWORD_ABSTRACT, { 0, 0, 1, 1, 1, 0 } }, ++ { "alias", KEYWORD_ALIAS, { 0, 0, 0, 1, 0, 0 } }, ++ { "align", KEYWORD_ALIGN, { 0, 0, 0, 1, 0, 0 } }, ++ { "asm", KEYWORD_ASM, { 0, 0, 0, 1, 0, 0 } }, ++ { "assert", KEYWORD_ASSERT, { 0, 0, 0, 1, 0, 0 } }, ++ { "auto", KEYWORD_AUTO, { 0, 0, 0, 1, 0, 0 } }, ++ { "bad_state", KEYWORD_BAD_STATE, { 0, 0, 0, 0, 0, 1 } }, ++ { "bad_trans", KEYWORD_BAD_TRANS, { 0, 0, 0, 0, 0, 1 } }, ++ { "bind", KEYWORD_BIND, { 0, 0, 0, 0, 0, 1 } }, ++ { "bind_var", KEYWORD_BIND_VAR, { 0, 0, 0, 0, 0, 1 } }, ++ { "bit", KEYWORD_BIT, { 0, 0, 0, 0, 0, 1 } }, ++ { "body", KEYWORD_BODY, { 0, 0, 0, 1, 0, 0 } }, ++ { "bool", KEYWORD_BOOL, { 0, 0, 0, 1, 0, 0 } }, ++ { "boolean", KEYWORD_BOOLEAN, { 0, 0, 0, 0, 1, 0 } }, ++ { "break", KEYWORD_BREAK, { 0, 0, 0, 1, 0, 0 } }, ++ { "byte", KEYWORD_BYTE, { 0, 0, 0, 1, 1, 0 } }, ++ { "case", KEYWORD_CASE, { 1, 1, 1, 1, 1, 0 } }, ++ { "cast", KEYWORD_CAST, { 0, 0, 0, 1, 0, 0 } }, ++ { "catch", KEYWORD_CATCH, { 0, 1, 1, 1, 0, 0 } }, ++ { "cdouble", KEYWORD_CDOUBLE, { 0, 0, 0, 1, 0, 0 } }, ++ { "cent", KEYWORD_CENT, { 0, 0, 0, 1, 0, 0 } }, ++ { "cfloat", KEYWORD_CFLOAT, { 0, 0, 0, 1, 0, 0 } }, ++ { "char", KEYWORD_CHAR, { 1, 1, 1, 1, 1, 0 } }, ++ { "class", KEYWORD_CLASS, { 0, 1, 1, 1, 1, 1 } }, ++ { "const", KEYWORD_CONST, { 1, 1, 1, 1, 1, 0 } }, ++ { "constraint", KEYWORD_CONSTRAINT, { 0, 0, 0, 0, 0, 1 } }, ++ { "continue", KEYWORD_CONTINUE, { 0, 0, 0, 1, 0, 0 } }, ++ { "coverage_block", KEYWORD_COVERAGE_BLOCK, { 0, 0, 0, 0, 0, 1 } }, ++ { "coverage_def", KEYWORD_COVERAGE_DEF, { 0, 0, 0, 0, 0, 1 } }, ++ { "creal", KEYWORD_CREAL, { 0, 0, 0, 1, 0, 0 } }, ++ { "dchar", KEYWORD_DCHAR, { 0, 0, 0, 1, 0, 0 } }, ++ { "debug", KEYWORD_DEBUG, { 0, 0, 0, 1, 0, 0 } }, ++ { "default", KEYWORD_DEFAULT, { 1, 1, 1, 1, 1, 0 } }, ++ { "delegate", KEYWORD_DELEGATE, { 0, 0, 1, 1, 0, 0 } }, ++ { "delete", KEYWORD_DELETE, { 0, 0, 0, 1, 0, 0 } }, ++ { "deprecated", KEYWORD_DEPRECATED, { 0, 0, 0, 1, 0, 0 } }, ++ { "do", KEYWORD_DO, { 1, 1, 1, 1, 1, 0 } }, ++ { "double", KEYWORD_DOUBLE, { 1, 1, 1, 1, 1, 0 } }, ++ { "else", KEYWORD_ELSE, { 1, 1, 1, 1, 1, 0 } }, ++ { "enum", KEYWORD_ENUM, { 1, 1, 1, 1, 0, 1 } }, ++ { "event", KEYWORD_EVENT, { 0, 0, 1, 0, 0, 1 } }, ++ { "explicit", KEYWORD_EXPLICIT, { 0, 1, 1, 1, 0, 0 } }, ++ { "export", KEYWORD_EXPORT, { 0, 0, 0, 1, 0, 0 } }, ++ { "extends", KEYWORD_EXTENDS, { 0, 0, 0, 0, 1, 1 } }, ++ { "extern", KEYWORD_EXTERN, { 1, 1, 1, 1, 0, 1 } }, ++ { "false", KEYWORD_FALSE, { 0, 0, 0, 1, 0, 0 } }, ++ { "final", KEYWORD_FINAL, { 0, 0, 0, 1, 1, 0 } }, ++ { "finally", KEYWORD_FINALLY, { 0, 0, 0, 1, 0, 0 } }, ++ { "float", KEYWORD_FLOAT, { 1, 1, 1, 1, 1, 0 } }, ++ { "for", KEYWORD_FOR, { 1, 1, 1, 1, 1, 0 } }, ++ { "foreach", KEYWORD_FOREACH, { 0, 0, 1, 1, 0, 0 } }, ++ { "foreach_reverse", KEYWORD_FOREACH_REVERSE, { 0, 0, 0, 1, 0, 0 } }, ++ { "friend", KEYWORD_FRIEND, { 0, 1, 0, 1, 0, 0 } }, ++ { "function", KEYWORD_FUNCTION, { 0, 0, 0, 1, 0, 1 } }, ++ { "goto", KEYWORD_GOTO, { 1, 1, 1, 1, 1, 0 } }, ++ { "idouble", KEYWORD_IDOUBLE, { 0, 0, 0, 1, 0, 0 } }, ++ { "if", KEYWORD_IF, { 1, 1, 1, 1, 1, 0 } }, ++ { "ifloat", KEYWORD_IFLOAT, { 0, 0, 0, 1, 0, 0 } }, ++ { "implements", KEYWORD_IMPLEMENTS, { 0, 0, 0, 0, 1, 0 } }, ++ { "import", KEYWORD_IMPORT, { 0, 0, 0, 1, 1, 0 } }, ++ { "in", KEYWORD_IN, { 0, 0, 0, 1, 0, 0 } }, ++ { "inline", KEYWORD_INLINE, { 0, 1, 0, 1, 0, 0 } }, ++ { "inout", KEYWORD_INOUT, { 0, 0, 0, 1, 0, 1 } }, ++ { "input", KEYWORD_INPUT, { 0, 0, 0, 0, 0, 1 } }, ++ { "int", KEYWORD_INT, { 1, 1, 1, 1, 1, 0 } }, ++ { "integer", KEYWORD_INTEGER, { 0, 0, 0, 0, 0, 1 } }, ++ { "interface", KEYWORD_INTERFACE, { 0, 0, 1, 1, 1, 1 } }, ++ { "internal", KEYWORD_INTERNAL, { 0, 0, 1, 0, 0, 0 } }, ++ { "invariant", KEYWORD_INVARIANT, { 0, 0, 0, 1, 0, 0 } }, ++ { "ireal", KEYWORD_IREAL, { 0, 0, 0, 1, 0, 0 } }, ++ { "is", KEYWORD_IS, { 0, 0, 0, 1, 0, 0 } }, ++ { "lazy", KEYWORD_LAZY, { 0, 0, 0, 1, 0, 0 } }, ++ { "local", KEYWORD_LOCAL, { 0, 0, 0, 0, 0, 1 } }, ++ { "long", KEYWORD_LONG, { 1, 1, 1, 1, 1, 0 } }, ++ { "m_bad_state", KEYWORD_M_BAD_STATE, { 0, 0, 0, 0, 0, 1 } }, ++ { "m_bad_trans", KEYWORD_M_BAD_TRANS, { 0, 0, 0, 0, 0, 1 } }, ++ { "m_state", KEYWORD_M_STATE, { 0, 0, 0, 0, 0, 1 } }, ++ { "m_trans", KEYWORD_M_TRANS, { 0, 0, 0, 0, 0, 1 } }, ++ { "mixin", KEYWORD_MIXIN, { 0, 0, 0, 1, 0, 0 } }, ++ { "module", KEYWORD_MODULE, { 0, 0, 0, 1, 0, 0 } }, ++ { "mutable", KEYWORD_MUTABLE, { 0, 1, 0, 1, 0, 0 } }, ++ { "namespace", KEYWORD_NAMESPACE, { 0, 1, 1, 1, 0, 0 } }, ++ { "native", KEYWORD_NATIVE, { 0, 0, 0, 0, 1, 0 } }, ++ { "new", KEYWORD_NEW, { 0, 1, 1, 1, 1, 0 } }, ++ { "newcov", KEYWORD_NEWCOV, { 0, 0, 0, 0, 0, 1 } }, ++ { "null", KEYWORD_NULL, { 0, 0, 0, 1, 0, 0 } }, ++ { "operator", KEYWORD_OPERATOR, { 0, 1, 1, 1, 0, 0 } }, ++ { "out", KEYWORD_OUT, { 0, 0, 0, 1, 0, 0 } }, ++ { "output", KEYWORD_OUTPUT, { 0, 0, 0, 0, 0, 1 } }, ++ { "overload", KEYWORD_OVERLOAD, { 0, 1, 0, 1, 0, 0 } }, ++ { "override", KEYWORD_OVERRIDE, { 0, 0, 1, 1, 0, 0 } }, ++ { "package", KEYWORD_PACKAGE, { 0, 0, 0, 1, 1, 0 } }, ++ { "packed", KEYWORD_PACKED, { 0, 0, 0, 0, 0, 1 } }, ++ { "port", KEYWORD_PORT, { 0, 0, 0, 0, 0, 1 } }, ++ { "pragma", KEYWORD_PRAGMA, { 0, 0, 0, 1, 0, 0 } }, ++ { "private", KEYWORD_PRIVATE, { 0, 1, 1, 1, 1, 0 } }, ++ { "program", KEYWORD_PROGRAM, { 0, 0, 0, 0, 0, 1 } }, ++ { "protected", KEYWORD_PROTECTED, { 0, 1, 1, 1, 1, 1 } }, ++ { "public", KEYWORD_PUBLIC, { 0, 1, 1, 1, 1, 1 } }, ++ { "real", KEYWORD_REAL, { 0, 0, 0, 1, 0, 0 } }, ++ { "register", KEYWORD_REGISTER, { 1, 1, 0, 1, 0, 0 } }, ++ { "return", KEYWORD_RETURN, { 1, 1, 1, 1, 1, 0 } }, ++ { "scope", KEYWORD_SCOPE, { 0, 0, 0, 1, 0, 0 } }, ++ { "shadow", KEYWORD_SHADOW, { 0, 0, 0, 0, 0, 1 } }, ++ { "short", KEYWORD_SHORT, { 1, 1, 1, 1, 1, 0 } }, ++ { "signed", KEYWORD_SIGNED, { 1, 1, 0, 1, 0, 0 } }, ++ { "state", KEYWORD_STATE, { 0, 0, 0, 0, 0, 1 } }, ++ { "static", KEYWORD_STATIC, { 1, 1, 1, 1, 1, 1 } }, ++ { "string", KEYWORD_STRING, { 0, 0, 1, 0, 0, 1 } }, ++ { "struct", KEYWORD_STRUCT, { 1, 1, 1, 1, 0, 0 } }, ++ { "super", KEYWORD_SUPER, { 0, 0, 0, 1, 0, 0 } }, ++ { "switch", KEYWORD_SWITCH, { 1, 1, 1, 1, 1, 0 } }, ++ { "synchronized", KEYWORD_SYNCHRONIZED, { 0, 0, 0, 1, 1, 0 } }, ++ { "task", KEYWORD_TASK, { 0, 0, 0, 0, 0, 1 } }, ++ { "template", KEYWORD_TEMPLATE, { 0, 1, 0, 1, 0, 0 } }, ++ { "this", KEYWORD_THIS, { 0, 1, 1, 1, 1, 0 } }, ++ { "throw", KEYWORD_THROW, { 0, 1, 1, 1, 1, 0 } }, ++ { "throws", KEYWORD_THROWS, { 0, 0, 0, 0, 1, 0 } }, ++ { "trans", KEYWORD_TRANS, { 0, 0, 0, 0, 0, 1 } }, ++ { "transient", KEYWORD_TRANSIENT, { 0, 0, 0, 0, 1, 0 } }, ++ { "transition", KEYWORD_TRANSITION, { 0, 0, 0, 0, 0, 1 } }, ++ { "true", KEYWORD_TRUE, { 0, 0, 0, 1, 0, 0 } }, ++ { "try", KEYWORD_TRY, { 0, 1, 1, 1, 0, 0 } }, ++ { "typedef", KEYWORD_TYPEDEF, { 1, 1, 1, 1, 0, 1 } }, ++ { "typeid", KEYWORD_TYPEID, { 0, 0, 0, 1, 0, 0 } }, ++ { "typename", KEYWORD_TYPENAME, { 0, 1, 0, 1, 0, 0 } }, ++ { "typeof", KEYWORD_TYPEOF, { 0, 0, 0, 1, 0, 0 } }, ++ { "ubyte", KEYWORD_UBYTE, { 0, 0, 0, 1, 0, 0 } }, ++ { "ucent", KEYWORD_UCENT, { 0, 0, 0, 1, 0, 0 } }, ++ { "uint", KEYWORD_UINT, { 0, 0, 1, 1, 0, 0 } }, ++ { "ulong", KEYWORD_ULONG, { 0, 0, 1, 1, 0, 0 } }, ++ { "union", KEYWORD_UNION, { 1, 1, 0, 1, 0, 0 } }, ++ { "unittest", KEYWORD_UNITTEST, { 0, 0, 0, 1, 0, 0 } }, ++ { "unsigned", KEYWORD_UNSIGNED, { 1, 1, 1, 1, 0, 0 } }, ++ { "ushort", KEYWORD_USHORT, { 0, 0, 1, 1, 0, 0 } }, ++ { "using", KEYWORD_USING, { 0, 1, 1, 1, 0, 0 } }, ++ { "version", KEYWORD_VERSION, { 0, 0, 0, 1, 0, 0 } }, ++ { "virtual", KEYWORD_VIRTUAL, { 0, 1, 1, 1, 0, 1 } }, ++ { "void", KEYWORD_VOID, { 1, 1, 1, 1, 1, 1 } }, ++ { "volatile", KEYWORD_VOLATILE, { 1, 1, 1, 1, 1, 0 } }, ++ { "wchar", KEYWORD_WCHAR, { 0, 0, 0, 1, 0, 0 } }, ++ { "wchar_t", KEYWORD_WCHAR_T, { 1, 1, 1, 1, 0, 0 } }, ++ { "while", KEYWORD_WHILE, { 1, 1, 1, 1, 1, 0 } }, ++ { "with", KEYWORD_WITH, { 0, 0, 0, 1, 0, 0 } }, + }; + + /* +@@ -595,7 +665,7 @@ + static const char *const names [] = { + "?", "base", "class", "enum", "event", "function", "ignore", + "interface", "namespace", "no mangle", "package", "program", +- "struct", "task", "union", ++ "struct", "task", "union", "version" + }; + Assert (sizeof (names) / sizeof (names [0]) == DECL_COUNT); + Assert ((int) declaration < DECL_COUNT); +@@ -671,6 +741,8 @@ + case KEYWORD_NAMESPACE: + case KEYWORD_STRUCT: + case KEYWORD_UNION: ++ case KEYWORD_VERSION: ++ case KEYWORD_TEMPLATE: + result = TRUE; + break; + +@@ -690,6 +762,7 @@ + case DECL_NAMESPACE: + case DECL_STRUCT: + case DECL_UNION: ++ case DECL_TEMPLATE: + result = TRUE; + break; + +@@ -725,6 +798,8 @@ + case DECL_CLASS: + if (isLanguage (Lang_java)) + accessDefault = ACCESS_DEFAULT; ++ else if(isLanguage(Lang_d)) ++ accessDefault = ACCESS_PUBLIC; + else + accessDefault = ACCESS_PRIVATE; + break; +@@ -807,13 +882,17 @@ + case TAG_FUNCTION: result = CK_FUNCTION; break; + case TAG_LOCAL: result = CK_LOCAL; break; + case TAG_MEMBER: result = CK_MEMBER; break; ++ case TAG_PACKAGE: result = CK_MODULE; break; + case TAG_NAMESPACE: result = CK_NAMESPACE; break; + case TAG_PROTOTYPE: result = CK_PROTOTYPE; break; + case TAG_STRUCT: result = CK_STRUCT; break; + case TAG_TYPEDEF: result = CK_TYPEDEF; break; ++ case TAG_TEMPLATE: result = CK_TEMPLATE; break; + case TAG_UNION: result = CK_UNION; break; + case TAG_VARIABLE: result = CK_VARIABLE; break; ++ case TAG_MIXIN: result = CK_MIXIN; break; + case TAG_EXTERN_VAR: result = CK_EXTERN_VARIABLE; break; ++ case TAG_VERSION: result = CK_VERSION; break; + + default: Assert ("Bad C tag type" == NULL); break; + } +@@ -938,12 +1017,15 @@ + case DECL_ENUM: type = TAG_ENUM; break; + case DECL_EVENT: type = TAG_EVENT; break; + case DECL_FUNCTION: type = TAG_FUNCTION; break; ++ case DECL_FUNCTION_TEMPLATE: type = TAG_FUNCTION_TEMPLATE; break; + case DECL_INTERFACE: type = TAG_INTERFACE; break; + case DECL_NAMESPACE: type = TAG_NAMESPACE; break; + case DECL_PROGRAM: type = TAG_PROGRAM; break; + case DECL_TASK: type = TAG_TASK; break; ++ case DECL_TEMPLATE: type = TAG_TEMPLATE; break; + case DECL_STRUCT: type = TAG_STRUCT; break; + case DECL_UNION: type = TAG_UNION; break; ++ case DECL_VERSION: type = TAG_VERSION; break; + + default: Assert ("Unexpected declaration" == NULL); break; + } +@@ -962,7 +1044,7 @@ + + static void addContextSeparator (vString *const scope) + { +- if (isLanguage (Lang_c) || isLanguage (Lang_cpp)) ++ if (isLanguage (Lang_c) || isLanguage (Lang_cpp) || isLanguage(Lang_d)) + vStringCatS (scope, "::"); + else if (isLanguage (Lang_java) || isLanguage (Lang_csharp)) + vStringCatS (scope, "."); +@@ -980,6 +1062,7 @@ + default: break; + + case TAG_FUNCTION: ++ case TAG_TEMPLATE: + case TAG_METHOD: + case TAG_PROTOTYPE: + if (vStringLength (Signature) > 0) +@@ -1252,6 +1335,8 @@ + case DECL_PROGRAM: + case DECL_STRUCT: + case DECL_UNION: ++ case DECL_TEMPLATE: ++ case DECL_VERSION: + qualifyCompoundTag (st, nameToken); + break; + default: break; +@@ -1535,6 +1620,34 @@ + } + } + ++static void readVersionName (tokenInfo *const token, const int firstChar) ++{ ++ vString *const name = token->name; ++ int c = firstChar; ++ ++ initToken (token); ++ ++ while (isident (c)) ++ { ++ vStringPut (name, c); ++ c = cppGetc (); ++ } ++ vStringTerminate (name); ++ cppGetc (); ++} ++ ++static void readVersion (statementInfo *const st) ++{ ++ tokenInfo *const token = activeToken (st); ++ Assert (isType (token, TOKEN_KEYWORD)); ++ skipToNonWhite (); ++ readVersionName (token, cppGetc ()); ++ token->type = TOKEN_NAME; ++ st->declaration = DECL_VERSION; ++ st->gotName = TRUE; ++ st->haveQualifyingName = TRUE; ++} ++ + static void processName (statementInfo *const st) + { + Assert (isType (activeToken (st), TOKEN_NAME)); +@@ -1744,6 +1857,7 @@ + case KEYWORD_LOCAL: setAccess (st, ACCESS_LOCAL); break; + case KEYWORD_LONG: st->declaration = DECL_BASE; break; + case KEYWORD_OPERATOR: readOperator (st); break; ++ case KEYWORD_MIXIN: st->declaration = DECL_MIXIN; break; + case KEYWORD_PRIVATE: setAccess (st, ACCESS_PRIVATE); break; + case KEYWORD_PROGRAM: st->declaration = DECL_PROGRAM; break; + case KEYWORD_PROTECTED: setAccess (st, ACCESS_PROTECTED); break; +@@ -1760,17 +1874,23 @@ + case KEYWORD_USING: skipStatement (st); break; + case KEYWORD_VOID: st->declaration = DECL_BASE; break; + case KEYWORD_VOLATILE: st->declaration = DECL_BASE; break; ++ case KEYWORD_VERSION: readVersion(st); break; + case KEYWORD_VIRTUAL: st->implementation = IMP_VIRTUAL; break; + case KEYWORD_WCHAR_T: st->declaration = DECL_BASE; break; +- ++ case KEYWORD_TEMPLATE: ++ if(isLanguage(Lang_d)) ++ st->declaration = DECL_TEMPLATE; ++ break; + case KEYWORD_NAMESPACE: readPackageOrNamespace (st, DECL_NAMESPACE); break; ++ case KEYWORD_MODULE: + case KEYWORD_PACKAGE: readPackageOrNamespace (st, DECL_PACKAGE); break; + + case KEYWORD_EVENT: + if (isLanguage (Lang_csharp)) + st->declaration = DECL_EVENT; + break; +- ++ ++ case KEYWORD_ALIAS: + case KEYWORD_TYPEDEF: + reinitStatement (st, FALSE); + st->scope = SCOPE_TYPEDEF; +@@ -1941,7 +2061,7 @@ + vStringCat (Signature, token->name); + } + break; +- ++ case KEYWORD_ALIAS: + case KEYWORD_CATCH: + case KEYWORD_CLASS: + case KEYWORD_EXPLICIT: +@@ -2317,6 +2437,10 @@ + st->gotParenName = TRUE; + if (! (c == '(' && info.nestedArgs)) + st->isPointer = info.isPointer; ++ //if( c == '(' && isType (prev, TOKEN_NAME)){ ++ // st->declaration = DECL_FUNCTION_TEMPLATE; ++ // copyToken (st->blockName, prev); ++ //} + } + else if (! st->gotArgs && info.isParamList) + { +@@ -2377,7 +2501,7 @@ + else + { + cppUngetc (c); +- if ((isLanguage (Lang_cpp) || isLanguage (Lang_csharp)) && ++ if ((isLanguage (Lang_cpp) || isLanguage (Lang_csharp) || isLanguage(Lang_d)) && + inheritingDeclaration (st->declaration)) + { + readParents (st, ':'); +@@ -2641,6 +2765,9 @@ + { + switch (st->declaration) + { ++ case DECL_TEMPLATE: ++ case DECL_VERSION: ++ st->inFunction = FALSE; + case DECL_CLASS: + case DECL_ENUM: + case DECL_INTERFACE: +@@ -2671,12 +2798,14 @@ + const tokenInfo *const token = activeToken (st); + const tokenInfo *const prev = prevToken (st, 1); + const tokenInfo *const prev2 = prevToken (st, 2); +- ++ const tokenInfo *const prev3 = prevToken (st, 3); + switch (token->type) + { + case TOKEN_NAME: + if (insideEnumBody (st)) + qualifyEnumeratorTag (st, token); ++ if (st->declaration == DECL_MIXIN) ++ makeTag (token, st, FALSE, TAG_MIXIN); + break; + #if 0 + case TOKEN_PACKAGE: +@@ -2687,17 +2816,27 @@ + case TOKEN_BRACE_OPEN: + if (isType (prev, TOKEN_ARGS)) + { +- if (st->haveQualifyingName) ++ if (st->declaration == DECL_TEMPLATE) ++ qualifyBlockTag (st, prev2); ++ else if (st->declaration == DECL_FUNCTION_TEMPLATE) { ++ qualifyFunctionTag (st, st->blockName); ++ } ++ else if (st->haveQualifyingName) + { +- if (! isLanguage (Lang_vera)) ++ if (! isLanguage (Lang_vera) && st->declaration != DECL_CLASS) + st->declaration = DECL_FUNCTION; + if (isType (prev2, TOKEN_NAME)) + copyToken (st->blockName, prev2); +- qualifyFunctionTag (st, prev2); ++ ++ if( st->declaration == DECL_CLASS) ++ qualifyBlockTag (st, prev2); ++ else ++ qualifyFunctionTag (st, prev2); + } + } + else if (isContextualStatement (st) || + st->declaration == DECL_NAMESPACE || ++ st->declaration == DECL_VERSION || + st->declaration == DECL_PROGRAM) + { + if (isType (prev, TOKEN_NAME)) +@@ -2838,7 +2977,6 @@ + Lang_c = language; + buildKeywordHash (language, 0); + } +- + static void initializeCppParser (const langType language) + { + Lang_cpp = language; +@@ -2851,16 +2989,23 @@ + buildKeywordHash (language, 2); + } + ++static void initializeDParser (const langType language) ++{ ++ Lang_d = language; ++ buildKeywordHash (language, 3); ++} ++ ++ + static void initializeJavaParser (const langType language) + { + Lang_java = language; +- buildKeywordHash (language, 3); ++ buildKeywordHash (language, 4); + } + + static void initializeVeraParser (const langType language) + { + Lang_vera = language; +- buildKeywordHash (language, 4); ++ buildKeywordHash (language, 5); + } + + extern parserDefinition* CParser (void) +@@ -2875,6 +3020,18 @@ + return def; + } + ++extern parserDefinition* DParser (void) ++{ ++ static const char *const extensions [] = { "d", NULL }; ++ parserDefinition* def = parserNew ("D"); ++ def->kinds = CKinds; ++ def->kindCount = KIND_COUNT (CKinds); ++ def->extensions = extensions; ++ def->parser2 = findCTags; ++ def->initialize = initializeDParser; ++ return def; ++} ++ + extern parserDefinition* CppParser (void) + { + static const char *const extensions [] = { +Gemeinsame Unterverzeichnisse: ctags-5.8.orig//gnu_regex und ctags-5.8//gnu_regex. +diff -u ctags-5.8.orig//parsers.h ctags-5.8//parsers.h +--- ctags-5.8.orig//parsers.h 2009-07-07 05:40:51.000000000 +0200 ++++ ctags-5.8//parsers.h 2010-05-22 02:29:02.777030096 +0200 +@@ -26,6 +26,7 @@ + CppParser, \ + CsharpParser, \ + CobolParser, \ ++ DParser,\ + DosBatchParser, \ + EiffelParser, \ + ErlangParser, \ +