Mercurial > projects > doodle

comparison nobuild/ctags.patch @ 137:9a9dcae45e08

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Misc support file changes
author David Bryant <bagnose@gmail.com>
date Sun, 30 Sep 2012 15:25:11 +0930
parents
children
comparison
equal deleted inserted replaced
136:752676232e4b 137:9a9dcae45e08
1 diff -u ctags-5.8.orig//c.c ctags-5.8//c.c
2 --- ctags-5.8.orig//c.c 2009-07-05 06:02:43.000000000 +0200
3 +++ ctags-5.8//c.c 2010-05-22 02:40:25.657027772 +0200
4 @@ -59,7 +59,7 @@
5 */
6 typedef enum eKeywordId {
7 KEYWORD_NONE = -1,
8 - KEYWORD_ATTRIBUTE, KEYWORD_ABSTRACT,
9 + KEYWORD_ALIAS, KEYWORD_ATTRIBUTE, KEYWORD_ABSTRACT,
10 KEYWORD_BOOLEAN, KEYWORD_BYTE, KEYWORD_BAD_STATE, KEYWORD_BAD_TRANS,
11 KEYWORD_BIND, KEYWORD_BIND_VAR, KEYWORD_BIT,
12 KEYWORD_CASE, KEYWORD_CATCH, KEYWORD_CHAR, KEYWORD_CLASS, KEYWORD_CONST,
13 @@ -91,7 +91,19 @@
14 KEYWORD_UINT, KEYWORD_ULONG, KEYWORD_UNION, KEYWORD_UNSIGNED, KEYWORD_USHORT,
15 KEYWORD_USING,
16 KEYWORD_VIRTUAL, KEYWORD_VOID, KEYWORD_VOLATILE,
17 - KEYWORD_WCHAR_T, KEYWORD_WHILE
18 + KEYWORD_WCHAR_T, KEYWORD_WHILE,
19 + KEYWORD_ALIGN, KEYWORD_ASM, KEYWORD_ASSERT, KEYWORD_AUTO,
20 + KEYWORD_BODY, KEYWORD_BOOL, KEYWORD_BREAK, KEYWORD_CAST,
21 + KEYWORD_CDOUBLE, KEYWORD_CENT, KEYWORD_CFLOAT, KEYWORD_CONTINUE,
22 + KEYWORD_CREAL, KEYWORD_DCHAR, KEYWORD_DEBUG,
23 + KEYWORD_DEPRECATED, KEYWORD_EXPORT, KEYWORD_FALSE, KEYWORD_FINALLY,
24 + KEYWORD_FOREACH_REVERSE, KEYWORD_IDOUBLE, KEYWORD_IFLOAT,
25 + KEYWORD_IN, KEYWORD_INVARIANT, KEYWORD_IREAL, KEYWORD_IS,
26 + KEYWORD_LAZY, KEYWORD_MIXIN, KEYWORD_MODULE, KEYWORD_NULL,
27 + KEYWORD_OUT, KEYWORD_PRAGMA, KEYWORD_REAL, KEYWORD_SCOPE,
28 + KEYWORD_SUPER, KEYWORD_TRUE, KEYWORD_TYPEID, KEYWORD_TYPEOF,
29 + KEYWORD_UBYTE, KEYWORD_UCENT, KEYWORD_UNITTEST, KEYWORD_VERSION,
30 + KEYWORD_WCHAR, KEYWORD_WITH
31 } keywordId;
32
33 /* Used to determine whether keyword is valid for the current language and
34 @@ -100,7 +112,7 @@
35 typedef struct sKeywordDesc {
36 const char *name;
37 keywordId id;
38 - short isValid [5]; /* indicates languages for which kw is valid */
39 + short isValid [6]; /* indicates languages for which kw is valid */
40 } keywordDesc;
41
42 /* Used for reporting the type of object parsed by nextToken ().
43 @@ -115,7 +127,7 @@
44 TOKEN_DOUBLE_COLON, /* double colon indicates nested-name-specifier */
45 TOKEN_KEYWORD,
46 TOKEN_NAME, /* an unknown name */
47 - TOKEN_PACKAGE, /* a Java package name */
48 + TOKEN_PACKAGE, /* a Java package name / a D module name */
49 TOKEN_PAREN_NAME, /* a single name in parentheses */
50 TOKEN_SEMICOLON, /* the semicolon character */
51 TOKEN_SPEC, /* a storage class specifier, qualifier, type, etc. */
52 @@ -140,15 +152,19 @@
53 DECL_ENUM,
54 DECL_EVENT,
55 DECL_FUNCTION,
56 + DECL_FUNCTION_TEMPLATE,
57 DECL_IGNORE, /* non-taggable "declaration" */
58 DECL_INTERFACE,
59 + DECL_MIXIN,
60 DECL_NAMESPACE,
61 DECL_NOMANGLE, /* C++ name demangling block */
62 DECL_PACKAGE,
63 DECL_PROGRAM, /* Vera program */
64 DECL_STRUCT,
65 DECL_TASK, /* Vera task */
66 + DECL_TEMPLATE,
67 DECL_UNION,
68 + DECL_VERSION, /* D conditional compile */
69 DECL_COUNT
70 } declType;
71
72 @@ -218,10 +234,12 @@
73 TAG_EVENT, /* event */
74 TAG_FIELD, /* field (Java) */
75 TAG_FUNCTION, /* function definition */
76 + TAG_FUNCTION_TEMPLATE, /* D function template */
77 TAG_INTERFACE, /* interface declaration */
78 TAG_LOCAL, /* local variable definition */
79 TAG_MEMBER, /* structure, class or interface member */
80 TAG_METHOD, /* method declaration */
81 + TAG_MIXIN, /* D mixin */
82 TAG_NAMESPACE, /* namespace name */
83 TAG_PACKAGE, /* package name */
84 TAG_PROGRAM, /* program name */
85 @@ -230,9 +248,11 @@
86 TAG_STRUCT, /* structure name */
87 TAG_TASK, /* task name */
88 TAG_TYPEDEF, /* typedef name */
89 + TAG_TEMPLATE, /* d template name */
90 TAG_UNION, /* union name */
91 TAG_VARIABLE, /* variable definition */
92 TAG_EXTERN_VAR, /* external variable declaration */
93 + TAG_VERSION, /* conditional template compilation */
94 TAG_COUNT /* must be last */
95 } tagType;
96
97 @@ -255,6 +275,7 @@
98 static langType Lang_c;
99 static langType Lang_cpp;
100 static langType Lang_csharp;
101 +static langType Lang_d;
102 static langType Lang_java;
103 static langType Lang_vera;
104 static vString *Signature;
105 @@ -267,9 +288,9 @@
106 typedef enum {
107 CK_UNDEFINED = -1,
108 CK_CLASS, CK_DEFINE, CK_ENUMERATOR, CK_FUNCTION,
109 - CK_ENUMERATION, CK_LOCAL, CK_MEMBER, CK_NAMESPACE, CK_PROTOTYPE,
110 - CK_STRUCT, CK_TYPEDEF, CK_UNION, CK_VARIABLE,
111 - CK_EXTERN_VARIABLE
112 + CK_ENUMERATION, CK_LOCAL, CK_MEMBER, CK_MODULE, CK_NAMESPACE, CK_PROTOTYPE,
113 + CK_STRUCT, CK_TYPEDEF, CK_TEMPLATE, CK_UNION, CK_VARIABLE,
114 + CK_EXTERN_VARIABLE, CK_MIXIN, CK_VERSION
115 } cKind;
116
117 static kindOption CKinds [] = {
118 @@ -280,13 +301,17 @@
119 { TRUE, 'g', "enum", "enumeration names"},
120 { FALSE, 'l', "local", "local variables"},
121 { TRUE, 'm', "member", "class, struct, and union members"},
122 + { TRUE, 'M', "module", "module"},
123 { TRUE, 'n', "namespace", "namespaces"},
124 { FALSE, 'p', "prototype", "function prototypes"},
125 { TRUE, 's', "struct", "structure names"},
126 { TRUE, 't', "typedef", "typedefs"},
127 + { TRUE, 'T', "template", "templates"},
128 { TRUE, 'u', "union", "union names"},
129 { TRUE, 'v', "variable", "variable definitions"},
130 { FALSE, 'x', "externvar", "external and forward variable declarations"},
131 + { TRUE, 'X', "mixin", "mixin"},
132 + { TRUE, 'V', "version", "conditional compilation"}
133 };
134
135 typedef enum {
136 @@ -356,110 +381,155 @@
137 };
138
139 static const keywordDesc KeywordTable [] = {
140 - /* C++ */
141 - /* ANSI C | C# Java */
142 - /* | | | | Vera */
143 - /* keyword keyword ID | | | | | */
144 - { "__attribute__", KEYWORD_ATTRIBUTE, { 1, 1, 1, 0, 0 } },
145 - { "abstract", KEYWORD_ABSTRACT, { 0, 0, 1, 1, 0 } },
146 - { "bad_state", KEYWORD_BAD_STATE, { 0, 0, 0, 0, 1 } },
147 - { "bad_trans", KEYWORD_BAD_TRANS, { 0, 0, 0, 0, 1 } },
148 - { "bind", KEYWORD_BIND, { 0, 0, 0, 0, 1 } },
149 - { "bind_var", KEYWORD_BIND_VAR, { 0, 0, 0, 0, 1 } },
150 - { "bit", KEYWORD_BIT, { 0, 0, 0, 0, 1 } },
151 - { "boolean", KEYWORD_BOOLEAN, { 0, 0, 0, 1, 0 } },
152 - { "byte", KEYWORD_BYTE, { 0, 0, 0, 1, 0 } },
153 - { "case", KEYWORD_CASE, { 1, 1, 1, 1, 0 } },
154 - { "catch", KEYWORD_CATCH, { 0, 1, 1, 0, 0 } },
155 - { "char", KEYWORD_CHAR, { 1, 1, 1, 1, 0 } },
156 - { "class", KEYWORD_CLASS, { 0, 1, 1, 1, 1 } },
157 - { "const", KEYWORD_CONST, { 1, 1, 1, 1, 0 } },
158 - { "constraint", KEYWORD_CONSTRAINT, { 0, 0, 0, 0, 1 } },
159 - { "coverage_block", KEYWORD_COVERAGE_BLOCK, { 0, 0, 0, 0, 1 } },
160 - { "coverage_def", KEYWORD_COVERAGE_DEF, { 0, 0, 0, 0, 1 } },
161 - { "do", KEYWORD_DO, { 1, 1, 1, 1, 0 } },
162 - { "default", KEYWORD_DEFAULT, { 1, 1, 1, 1, 0 } },
163 - { "delegate", KEYWORD_DELEGATE, { 0, 0, 1, 0, 0 } },
164 - { "delete", KEYWORD_DELETE, { 0, 1, 0, 0, 0 } },
165 - { "double", KEYWORD_DOUBLE, { 1, 1, 1, 1, 0 } },
166 - { "else", KEYWORD_ELSE, { 1, 1, 1, 1, 0 } },
167 - { "enum", KEYWORD_ENUM, { 1, 1, 1, 1, 1 } },
168 - { "event", KEYWORD_EVENT, { 0, 0, 1, 0, 1 } },
169 - { "explicit", KEYWORD_EXPLICIT, { 0, 1, 1, 0, 0 } },
170 - { "extends", KEYWORD_EXTENDS, { 0, 0, 0, 1, 1 } },
171 - { "extern", KEYWORD_EXTERN, { 1, 1, 1, 0, 1 } },
172 - { "final", KEYWORD_FINAL, { 0, 0, 0, 1, 0 } },
173 - { "float", KEYWORD_FLOAT, { 1, 1, 1, 1, 0 } },
174 - { "for", KEYWORD_FOR, { 1, 1, 1, 1, 0 } },
175 - { "foreach", KEYWORD_FOREACH, { 0, 0, 1, 0, 0 } },
176 - { "friend", KEYWORD_FRIEND, { 0, 1, 0, 0, 0 } },
177 - { "function", KEYWORD_FUNCTION, { 0, 0, 0, 0, 1 } },
178 - { "goto", KEYWORD_GOTO, { 1, 1, 1, 1, 0 } },
179 - { "if", KEYWORD_IF, { 1, 1, 1, 1, 0 } },
180 - { "implements", KEYWORD_IMPLEMENTS, { 0, 0, 0, 1, 0 } },
181 - { "import", KEYWORD_IMPORT, { 0, 0, 0, 1, 0 } },
182 - { "inline", KEYWORD_INLINE, { 0, 1, 0, 0, 0 } },
183 - { "inout", KEYWORD_INOUT, { 0, 0, 0, 0, 1 } },
184 - { "input", KEYWORD_INPUT, { 0, 0, 0, 0, 1 } },
185 - { "int", KEYWORD_INT, { 1, 1, 1, 1, 0 } },
186 - { "integer", KEYWORD_INTEGER, { 0, 0, 0, 0, 1 } },
187 - { "interface", KEYWORD_INTERFACE, { 0, 0, 1, 1, 1 } },
188 - { "internal", KEYWORD_INTERNAL, { 0, 0, 1, 0, 0 } },
189 - { "local", KEYWORD_LOCAL, { 0, 0, 0, 0, 1 } },
190 - { "long", KEYWORD_LONG, { 1, 1, 1, 1, 0 } },
191 - { "m_bad_state", KEYWORD_M_BAD_STATE, { 0, 0, 0, 0, 1 } },
192 - { "m_bad_trans", KEYWORD_M_BAD_TRANS, { 0, 0, 0, 0, 1 } },
193 - { "m_state", KEYWORD_M_STATE, { 0, 0, 0, 0, 1 } },
194 - { "m_trans", KEYWORD_M_TRANS, { 0, 0, 0, 0, 1 } },
195 - { "mutable", KEYWORD_MUTABLE, { 0, 1, 0, 0, 0 } },
196 - { "namespace", KEYWORD_NAMESPACE, { 0, 1, 1, 0, 0 } },
197 - { "native", KEYWORD_NATIVE, { 0, 0, 0, 1, 0 } },
198 - { "new", KEYWORD_NEW, { 0, 1, 1, 1, 0 } },
199 - { "newcov", KEYWORD_NEWCOV, { 0, 0, 0, 0, 1 } },
200 - { "operator", KEYWORD_OPERATOR, { 0, 1, 1, 0, 0 } },
201 - { "output", KEYWORD_OUTPUT, { 0, 0, 0, 0, 1 } },
202 - { "overload", KEYWORD_OVERLOAD, { 0, 1, 0, 0, 0 } },
203 - { "override", KEYWORD_OVERRIDE, { 0, 0, 1, 0, 0 } },
204 - { "package", KEYWORD_PACKAGE, { 0, 0, 0, 1, 0 } },
205 - { "packed", KEYWORD_PACKED, { 0, 0, 0, 0, 1 } },
206 - { "port", KEYWORD_PORT, { 0, 0, 0, 0, 1 } },
207 - { "private", KEYWORD_PRIVATE, { 0, 1, 1, 1, 0 } },
208 - { "program", KEYWORD_PROGRAM, { 0, 0, 0, 0, 1 } },
209 - { "protected", KEYWORD_PROTECTED, { 0, 1, 1, 1, 1 } },
210 - { "public", KEYWORD_PUBLIC, { 0, 1, 1, 1, 1 } },
211 - { "register", KEYWORD_REGISTER, { 1, 1, 0, 0, 0 } },
212 - { "return", KEYWORD_RETURN, { 1, 1, 1, 1, 0 } },
213 - { "shadow", KEYWORD_SHADOW, { 0, 0, 0, 0, 1 } },
214 - { "short", KEYWORD_SHORT, { 1, 1, 1, 1, 0 } },
215 - { "signed", KEYWORD_SIGNED, { 1, 1, 0, 0, 0 } },
216 - { "state", KEYWORD_STATE, { 0, 0, 0, 0, 1 } },
217 - { "static", KEYWORD_STATIC, { 1, 1, 1, 1, 1 } },
218 - { "string", KEYWORD_STRING, { 0, 0, 1, 0, 1 } },
219 - { "struct", KEYWORD_STRUCT, { 1, 1, 1, 0, 0 } },
220 - { "switch", KEYWORD_SWITCH, { 1, 1, 1, 1, 0 } },
221 - { "synchronized", KEYWORD_SYNCHRONIZED, { 0, 0, 0, 1, 0 } },
222 - { "task", KEYWORD_TASK, { 0, 0, 0, 0, 1 } },
223 - { "template", KEYWORD_TEMPLATE, { 0, 1, 0, 0, 0 } },
224 - { "this", KEYWORD_THIS, { 0, 1, 1, 1, 0 } },
225 - { "throw", KEYWORD_THROW, { 0, 1, 1, 1, 0 } },
226 - { "throws", KEYWORD_THROWS, { 0, 0, 0, 1, 0 } },
227 - { "trans", KEYWORD_TRANS, { 0, 0, 0, 0, 1 } },
228 - { "transition", KEYWORD_TRANSITION, { 0, 0, 0, 0, 1 } },
229 - { "transient", KEYWORD_TRANSIENT, { 0, 0, 0, 1, 0 } },
230 - { "try", KEYWORD_TRY, { 0, 1, 1, 0, 0 } },
231 - { "typedef", KEYWORD_TYPEDEF, { 1, 1, 1, 0, 1 } },
232 - { "typename", KEYWORD_TYPENAME, { 0, 1, 0, 0, 0 } },
233 - { "uint", KEYWORD_UINT, { 0, 0, 1, 0, 0 } },
234 - { "ulong", KEYWORD_ULONG, { 0, 0, 1, 0, 0 } },
235 - { "union", KEYWORD_UNION, { 1, 1, 0, 0, 0 } },
236 - { "unsigned", KEYWORD_UNSIGNED, { 1, 1, 1, 0, 0 } },
237 - { "ushort", KEYWORD_USHORT, { 0, 0, 1, 0, 0 } },
238 - { "using", KEYWORD_USING, { 0, 1, 1, 0, 0 } },
239 - { "virtual", KEYWORD_VIRTUAL, { 0, 1, 1, 0, 1 } },
240 - { "void", KEYWORD_VOID, { 1, 1, 1, 1, 1 } },
241 - { "volatile", KEYWORD_VOLATILE, { 1, 1, 1, 1, 0 } },
242 - { "wchar_t", KEYWORD_WCHAR_T, { 1, 1, 1, 0, 0 } },
243 - { "while", KEYWORD_WHILE, { 1, 1, 1, 1, 0 } }
244 + /* C++ D */
245 + /* ANSI C | C# | Java */
246 + /* | | | | | Vera */
247 + /* keyword keyword ID | | | | | | */
248 + { "__attribute__", KEYWORD_ATTRIBUTE, { 1, 1, 1, 1, 0, 0 } },
249 + { "abstract", KEYWORD_ABSTRACT, { 0, 0, 1, 1, 1, 0 } },
250 + { "alias", KEYWORD_ALIAS, { 0, 0, 0, 1, 0, 0 } },
251 + { "align", KEYWORD_ALIGN, { 0, 0, 0, 1, 0, 0 } },
252 + { "asm", KEYWORD_ASM, { 0, 0, 0, 1, 0, 0 } },
253 + { "assert", KEYWORD_ASSERT, { 0, 0, 0, 1, 0, 0 } },
254 + { "auto", KEYWORD_AUTO, { 0, 0, 0, 1, 0, 0 } },
255 + { "bad_state", KEYWORD_BAD_STATE, { 0, 0, 0, 0, 0, 1 } },
256 + { "bad_trans", KEYWORD_BAD_TRANS, { 0, 0, 0, 0, 0, 1 } },
257 + { "bind", KEYWORD_BIND, { 0, 0, 0, 0, 0, 1 } },
258 + { "bind_var", KEYWORD_BIND_VAR, { 0, 0, 0, 0, 0, 1 } },
259 + { "bit", KEYWORD_BIT, { 0, 0, 0, 0, 0, 1 } },
260 + { "body", KEYWORD_BODY, { 0, 0, 0, 1, 0, 0 } },
261 + { "bool", KEYWORD_BOOL, { 0, 0, 0, 1, 0, 0 } },
262 + { "boolean", KEYWORD_BOOLEAN, { 0, 0, 0, 0, 1, 0 } },
263 + { "break", KEYWORD_BREAK, { 0, 0, 0, 1, 0, 0 } },
264 + { "byte", KEYWORD_BYTE, { 0, 0, 0, 1, 1, 0 } },
265 + { "case", KEYWORD_CASE, { 1, 1, 1, 1, 1, 0 } },
266 + { "cast", KEYWORD_CAST, { 0, 0, 0, 1, 0, 0 } },
267 + { "catch", KEYWORD_CATCH, { 0, 1, 1, 1, 0, 0 } },
268 + { "cdouble", KEYWORD_CDOUBLE, { 0, 0, 0, 1, 0, 0 } },
269 + { "cent", KEYWORD_CENT, { 0, 0, 0, 1, 0, 0 } },
270 + { "cfloat", KEYWORD_CFLOAT, { 0, 0, 0, 1, 0, 0 } },
271 + { "char", KEYWORD_CHAR, { 1, 1, 1, 1, 1, 0 } },
272 + { "class", KEYWORD_CLASS, { 0, 1, 1, 1, 1, 1 } },
273 + { "const", KEYWORD_CONST, { 1, 1, 1, 1, 1, 0 } },
274 + { "constraint", KEYWORD_CONSTRAINT, { 0, 0, 0, 0, 0, 1 } },
275 + { "continue", KEYWORD_CONTINUE, { 0, 0, 0, 1, 0, 0 } },
276 + { "coverage_block", KEYWORD_COVERAGE_BLOCK, { 0, 0, 0, 0, 0, 1 } },
277 + { "coverage_def", KEYWORD_COVERAGE_DEF, { 0, 0, 0, 0, 0, 1 } },
278 + { "creal", KEYWORD_CREAL, { 0, 0, 0, 1, 0, 0 } },
279 + { "dchar", KEYWORD_DCHAR, { 0, 0, 0, 1, 0, 0 } },
280 + { "debug", KEYWORD_DEBUG, { 0, 0, 0, 1, 0, 0 } },
281 + { "default", KEYWORD_DEFAULT, { 1, 1, 1, 1, 1, 0 } },
282 + { "delegate", KEYWORD_DELEGATE, { 0, 0, 1, 1, 0, 0 } },
283 + { "delete", KEYWORD_DELETE, { 0, 0, 0, 1, 0, 0 } },
284 + { "deprecated", KEYWORD_DEPRECATED, { 0, 0, 0, 1, 0, 0 } },
285 + { "do", KEYWORD_DO, { 1, 1, 1, 1, 1, 0 } },
286 + { "double", KEYWORD_DOUBLE, { 1, 1, 1, 1, 1, 0 } },
287 + { "else", KEYWORD_ELSE, { 1, 1, 1, 1, 1, 0 } },
288 + { "enum", KEYWORD_ENUM, { 1, 1, 1, 1, 0, 1 } },
289 + { "event", KEYWORD_EVENT, { 0, 0, 1, 0, 0, 1 } },
290 + { "explicit", KEYWORD_EXPLICIT, { 0, 1, 1, 1, 0, 0 } },
291 + { "export", KEYWORD_EXPORT, { 0, 0, 0, 1, 0, 0 } },
292 + { "extends", KEYWORD_EXTENDS, { 0, 0, 0, 0, 1, 1 } },
293 + { "extern", KEYWORD_EXTERN, { 1, 1, 1, 1, 0, 1 } },
294 + { "false", KEYWORD_FALSE, { 0, 0, 0, 1, 0, 0 } },
295 + { "final", KEYWORD_FINAL, { 0, 0, 0, 1, 1, 0 } },
296 + { "finally", KEYWORD_FINALLY, { 0, 0, 0, 1, 0, 0 } },
297 + { "float", KEYWORD_FLOAT, { 1, 1, 1, 1, 1, 0 } },
298 + { "for", KEYWORD_FOR, { 1, 1, 1, 1, 1, 0 } },
299 + { "foreach", KEYWORD_FOREACH, { 0, 0, 1, 1, 0, 0 } },
300 + { "foreach_reverse", KEYWORD_FOREACH_REVERSE, { 0, 0, 0, 1, 0, 0 } },
301 + { "friend", KEYWORD_FRIEND, { 0, 1, 0, 1, 0, 0 } },
302 + { "function", KEYWORD_FUNCTION, { 0, 0, 0, 1, 0, 1 } },
303 + { "goto", KEYWORD_GOTO, { 1, 1, 1, 1, 1, 0 } },
304 + { "idouble", KEYWORD_IDOUBLE, { 0, 0, 0, 1, 0, 0 } },
305 + { "if", KEYWORD_IF, { 1, 1, 1, 1, 1, 0 } },
306 + { "ifloat", KEYWORD_IFLOAT, { 0, 0, 0, 1, 0, 0 } },
307 + { "implements", KEYWORD_IMPLEMENTS, { 0, 0, 0, 0, 1, 0 } },
308 + { "import", KEYWORD_IMPORT, { 0, 0, 0, 1, 1, 0 } },
309 + { "in", KEYWORD_IN, { 0, 0, 0, 1, 0, 0 } },
310 + { "inline", KEYWORD_INLINE, { 0, 1, 0, 1, 0, 0 } },
311 + { "inout", KEYWORD_INOUT, { 0, 0, 0, 1, 0, 1 } },
312 + { "input", KEYWORD_INPUT, { 0, 0, 0, 0, 0, 1 } },
313 + { "int", KEYWORD_INT, { 1, 1, 1, 1, 1, 0 } },
314 + { "integer", KEYWORD_INTEGER, { 0, 0, 0, 0, 0, 1 } },
315 + { "interface", KEYWORD_INTERFACE, { 0, 0, 1, 1, 1, 1 } },
316 + { "internal", KEYWORD_INTERNAL, { 0, 0, 1, 0, 0, 0 } },
317 + { "invariant", KEYWORD_INVARIANT, { 0, 0, 0, 1, 0, 0 } },
318 + { "ireal", KEYWORD_IREAL, { 0, 0, 0, 1, 0, 0 } },
319 + { "is", KEYWORD_IS, { 0, 0, 0, 1, 0, 0 } },
320 + { "lazy", KEYWORD_LAZY, { 0, 0, 0, 1, 0, 0 } },
321 + { "local", KEYWORD_LOCAL, { 0, 0, 0, 0, 0, 1 } },
322 + { "long", KEYWORD_LONG, { 1, 1, 1, 1, 1, 0 } },
323 + { "m_bad_state", KEYWORD_M_BAD_STATE, { 0, 0, 0, 0, 0, 1 } },
324 + { "m_bad_trans", KEYWORD_M_BAD_TRANS, { 0, 0, 0, 0, 0, 1 } },
325 + { "m_state", KEYWORD_M_STATE, { 0, 0, 0, 0, 0, 1 } },
326 + { "m_trans", KEYWORD_M_TRANS, { 0, 0, 0, 0, 0, 1 } },
327 + { "mixin", KEYWORD_MIXIN, { 0, 0, 0, 1, 0, 0 } },
328 + { "module", KEYWORD_MODULE, { 0, 0, 0, 1, 0, 0 } },
329 + { "mutable", KEYWORD_MUTABLE, { 0, 1, 0, 1, 0, 0 } },
330 + { "namespace", KEYWORD_NAMESPACE, { 0, 1, 1, 1, 0, 0 } },
331 + { "native", KEYWORD_NATIVE, { 0, 0, 0, 0, 1, 0 } },
332 + { "new", KEYWORD_NEW, { 0, 1, 1, 1, 1, 0 } },
333 + { "newcov", KEYWORD_NEWCOV, { 0, 0, 0, 0, 0, 1 } },
334 + { "null", KEYWORD_NULL, { 0, 0, 0, 1, 0, 0 } },
335 + { "operator", KEYWORD_OPERATOR, { 0, 1, 1, 1, 0, 0 } },
336 + { "out", KEYWORD_OUT, { 0, 0, 0, 1, 0, 0 } },
337 + { "output", KEYWORD_OUTPUT, { 0, 0, 0, 0, 0, 1 } },
338 + { "overload", KEYWORD_OVERLOAD, { 0, 1, 0, 1, 0, 0 } },
339 + { "override", KEYWORD_OVERRIDE, { 0, 0, 1, 1, 0, 0 } },
340 + { "package", KEYWORD_PACKAGE, { 0, 0, 0, 1, 1, 0 } },
341 + { "packed", KEYWORD_PACKED, { 0, 0, 0, 0, 0, 1 } },
342 + { "port", KEYWORD_PORT, { 0, 0, 0, 0, 0, 1 } },
343 + { "pragma", KEYWORD_PRAGMA, { 0, 0, 0, 1, 0, 0 } },
344 + { "private", KEYWORD_PRIVATE, { 0, 1, 1, 1, 1, 0 } },
345 + { "program", KEYWORD_PROGRAM, { 0, 0, 0, 0, 0, 1 } },
346 + { "protected", KEYWORD_PROTECTED, { 0, 1, 1, 1, 1, 1 } },
347 + { "public", KEYWORD_PUBLIC, { 0, 1, 1, 1, 1, 1 } },
348 + { "real", KEYWORD_REAL, { 0, 0, 0, 1, 0, 0 } },
349 + { "register", KEYWORD_REGISTER, { 1, 1, 0, 1, 0, 0 } },
350 + { "return", KEYWORD_RETURN, { 1, 1, 1, 1, 1, 0 } },
351 + { "scope", KEYWORD_SCOPE, { 0, 0, 0, 1, 0, 0 } },
352 + { "shadow", KEYWORD_SHADOW, { 0, 0, 0, 0, 0, 1 } },
353 + { "short", KEYWORD_SHORT, { 1, 1, 1, 1, 1, 0 } },
354 + { "signed", KEYWORD_SIGNED, { 1, 1, 0, 1, 0, 0 } },
355 + { "state", KEYWORD_STATE, { 0, 0, 0, 0, 0, 1 } },
356 + { "static", KEYWORD_STATIC, { 1, 1, 1, 1, 1, 1 } },
357 + { "string", KEYWORD_STRING, { 0, 0, 1, 0, 0, 1 } },
358 + { "struct", KEYWORD_STRUCT, { 1, 1, 1, 1, 0, 0 } },
359 + { "super", KEYWORD_SUPER, { 0, 0, 0, 1, 0, 0 } },
360 + { "switch", KEYWORD_SWITCH, { 1, 1, 1, 1, 1, 0 } },
361 + { "synchronized", KEYWORD_SYNCHRONIZED, { 0, 0, 0, 1, 1, 0 } },
362 + { "task", KEYWORD_TASK, { 0, 0, 0, 0, 0, 1 } },
363 + { "template", KEYWORD_TEMPLATE, { 0, 1, 0, 1, 0, 0 } },
364 + { "this", KEYWORD_THIS, { 0, 1, 1, 1, 1, 0 } },
365 + { "throw", KEYWORD_THROW, { 0, 1, 1, 1, 1, 0 } },
366 + { "throws", KEYWORD_THROWS, { 0, 0, 0, 0, 1, 0 } },
367 + { "trans", KEYWORD_TRANS, { 0, 0, 0, 0, 0, 1 } },
368 + { "transient", KEYWORD_TRANSIENT, { 0, 0, 0, 0, 1, 0 } },
369 + { "transition", KEYWORD_TRANSITION, { 0, 0, 0, 0, 0, 1 } },
370 + { "true", KEYWORD_TRUE, { 0, 0, 0, 1, 0, 0 } },
371 + { "try", KEYWORD_TRY, { 0, 1, 1, 1, 0, 0 } },
372 + { "typedef", KEYWORD_TYPEDEF, { 1, 1, 1, 1, 0, 1 } },
373 + { "typeid", KEYWORD_TYPEID, { 0, 0, 0, 1, 0, 0 } },
374 + { "typename", KEYWORD_TYPENAME, { 0, 1, 0, 1, 0, 0 } },
375 + { "typeof", KEYWORD_TYPEOF, { 0, 0, 0, 1, 0, 0 } },
376 + { "ubyte", KEYWORD_UBYTE, { 0, 0, 0, 1, 0, 0 } },
377 + { "ucent", KEYWORD_UCENT, { 0, 0, 0, 1, 0, 0 } },
378 + { "uint", KEYWORD_UINT, { 0, 0, 1, 1, 0, 0 } },
379 + { "ulong", KEYWORD_ULONG, { 0, 0, 1, 1, 0, 0 } },
380 + { "union", KEYWORD_UNION, { 1, 1, 0, 1, 0, 0 } },
381 + { "unittest", KEYWORD_UNITTEST, { 0, 0, 0, 1, 0, 0 } },
382 + { "unsigned", KEYWORD_UNSIGNED, { 1, 1, 1, 1, 0, 0 } },
383 + { "ushort", KEYWORD_USHORT, { 0, 0, 1, 1, 0, 0 } },
384 + { "using", KEYWORD_USING, { 0, 1, 1, 1, 0, 0 } },
385 + { "version", KEYWORD_VERSION, { 0, 0, 0, 1, 0, 0 } },
386 + { "virtual", KEYWORD_VIRTUAL, { 0, 1, 1, 1, 0, 1 } },
387 + { "void", KEYWORD_VOID, { 1, 1, 1, 1, 1, 1 } },
388 + { "volatile", KEYWORD_VOLATILE, { 1, 1, 1, 1, 1, 0 } },
389 + { "wchar", KEYWORD_WCHAR, { 0, 0, 0, 1, 0, 0 } },
390 + { "wchar_t", KEYWORD_WCHAR_T, { 1, 1, 1, 1, 0, 0 } },
391 + { "while", KEYWORD_WHILE, { 1, 1, 1, 1, 1, 0 } },
392 + { "with", KEYWORD_WITH, { 0, 0, 0, 1, 0, 0 } },
393 };
394
395 /*
396 @@ -595,7 +665,7 @@
397 static const char *const names [] = {
398 "?", "base", "class", "enum", "event", "function", "ignore",
399 "interface", "namespace", "no mangle", "package", "program",
400 - "struct", "task", "union",
401 + "struct", "task", "union", "version"
402 };
403 Assert (sizeof (names) / sizeof (names [0]) == DECL_COUNT);
404 Assert ((int) declaration < DECL_COUNT);
405 @@ -671,6 +741,8 @@
406 case KEYWORD_NAMESPACE:
407 case KEYWORD_STRUCT:
408 case KEYWORD_UNION:
409 + case KEYWORD_VERSION:
410 + case KEYWORD_TEMPLATE:
411 result = TRUE;
412 break;
413
414 @@ -690,6 +762,7 @@
415 case DECL_NAMESPACE:
416 case DECL_STRUCT:
417 case DECL_UNION:
418 + case DECL_TEMPLATE:
419 result = TRUE;
420 break;
421
422 @@ -725,6 +798,8 @@
423 case DECL_CLASS:
424 if (isLanguage (Lang_java))
425 accessDefault = ACCESS_DEFAULT;
426 + else if(isLanguage(Lang_d))
427 + accessDefault = ACCESS_PUBLIC;
428 else
429 accessDefault = ACCESS_PRIVATE;
430 break;
431 @@ -807,13 +882,17 @@
432 case TAG_FUNCTION: result = CK_FUNCTION; break;
433 case TAG_LOCAL: result = CK_LOCAL; break;
434 case TAG_MEMBER: result = CK_MEMBER; break;
435 + case TAG_PACKAGE: result = CK_MODULE; break;
436 case TAG_NAMESPACE: result = CK_NAMESPACE; break;
437 case TAG_PROTOTYPE: result = CK_PROTOTYPE; break;
438 case TAG_STRUCT: result = CK_STRUCT; break;
439 case TAG_TYPEDEF: result = CK_TYPEDEF; break;
440 + case TAG_TEMPLATE: result = CK_TEMPLATE; break;
441 case TAG_UNION: result = CK_UNION; break;
442 case TAG_VARIABLE: result = CK_VARIABLE; break;
443 + case TAG_MIXIN: result = CK_MIXIN; break;
444 case TAG_EXTERN_VAR: result = CK_EXTERN_VARIABLE; break;
445 + case TAG_VERSION: result = CK_VERSION; break;
446
447 default: Assert ("Bad C tag type" == NULL); break;
448 }
449 @@ -938,12 +1017,15 @@
450 case DECL_ENUM: type = TAG_ENUM; break;
451 case DECL_EVENT: type = TAG_EVENT; break;
452 case DECL_FUNCTION: type = TAG_FUNCTION; break;
453 + case DECL_FUNCTION_TEMPLATE: type = TAG_FUNCTION_TEMPLATE; break;
454 case DECL_INTERFACE: type = TAG_INTERFACE; break;
455 case DECL_NAMESPACE: type = TAG_NAMESPACE; break;
456 case DECL_PROGRAM: type = TAG_PROGRAM; break;
457 case DECL_TASK: type = TAG_TASK; break;
458 + case DECL_TEMPLATE: type = TAG_TEMPLATE; break;
459 case DECL_STRUCT: type = TAG_STRUCT; break;
460 case DECL_UNION: type = TAG_UNION; break;
461 + case DECL_VERSION: type = TAG_VERSION; break;
462
463 default: Assert ("Unexpected declaration" == NULL); break;
464 }
465 @@ -962,7 +1044,7 @@
466
467 static void addContextSeparator (vString *const scope)
468 {
469 - if (isLanguage (Lang_c) || isLanguage (Lang_cpp))
470 + if (isLanguage (Lang_c) || isLanguage (Lang_cpp) || isLanguage(Lang_d))
471 vStringCatS (scope, "::");
472 else if (isLanguage (Lang_java) || isLanguage (Lang_csharp))
473 vStringCatS (scope, ".");
474 @@ -980,6 +1062,7 @@
475 default: break;
476
477 case TAG_FUNCTION:
478 + case TAG_TEMPLATE:
479 case TAG_METHOD:
480 case TAG_PROTOTYPE:
481 if (vStringLength (Signature) > 0)
482 @@ -1252,6 +1335,8 @@
483 case DECL_PROGRAM:
484 case DECL_STRUCT:
485 case DECL_UNION:
486 + case DECL_TEMPLATE:
487 + case DECL_VERSION:
488 qualifyCompoundTag (st, nameToken);
489 break;
490 default: break;
491 @@ -1535,6 +1620,34 @@
492 }
493 }
494
495 +static void readVersionName (tokenInfo *const token, const int firstChar)
496 +{
497 + vString *const name = token->name;
498 + int c = firstChar;
499 +
500 + initToken (token);
501 +
502 + while (isident (c))
503 + {
504 + vStringPut (name, c);
505 + c = cppGetc ();
506 + }
507 + vStringTerminate (name);
508 + cppGetc ();
509 +}
510 +
511 +static void readVersion (statementInfo *const st)
512 +{
513 + tokenInfo *const token = activeToken (st);
514 + Assert (isType (token, TOKEN_KEYWORD));
515 + skipToNonWhite ();
516 + readVersionName (token, cppGetc ());
517 + token->type = TOKEN_NAME;
518 + st->declaration = DECL_VERSION;
519 + st->gotName = TRUE;
520 + st->haveQualifyingName = TRUE;
521 +}
522 +
523 static void processName (statementInfo *const st)
524 {
525 Assert (isType (activeToken (st), TOKEN_NAME));
526 @@ -1744,6 +1857,7 @@
527 case KEYWORD_LOCAL: setAccess (st, ACCESS_LOCAL); break;
528 case KEYWORD_LONG: st->declaration = DECL_BASE; break;
529 case KEYWORD_OPERATOR: readOperator (st); break;
530 + case KEYWORD_MIXIN: st->declaration = DECL_MIXIN; break;
531 case KEYWORD_PRIVATE: setAccess (st, ACCESS_PRIVATE); break;
532 case KEYWORD_PROGRAM: st->declaration = DECL_PROGRAM; break;
533 case KEYWORD_PROTECTED: setAccess (st, ACCESS_PROTECTED); break;
534 @@ -1760,17 +1874,23 @@
535 case KEYWORD_USING: skipStatement (st); break;
536 case KEYWORD_VOID: st->declaration = DECL_BASE; break;
537 case KEYWORD_VOLATILE: st->declaration = DECL_BASE; break;
538 + case KEYWORD_VERSION: readVersion(st); break;
539 case KEYWORD_VIRTUAL: st->implementation = IMP_VIRTUAL; break;
540 case KEYWORD_WCHAR_T: st->declaration = DECL_BASE; break;
541 -
542 + case KEYWORD_TEMPLATE:
543 + if(isLanguage(Lang_d))
544 + st->declaration = DECL_TEMPLATE;
545 + break;
546 case KEYWORD_NAMESPACE: readPackageOrNamespace (st, DECL_NAMESPACE); break;
547 + case KEYWORD_MODULE:
548 case KEYWORD_PACKAGE: readPackageOrNamespace (st, DECL_PACKAGE); break;
549
550 case KEYWORD_EVENT:
551 if (isLanguage (Lang_csharp))
552 st->declaration = DECL_EVENT;
553 break;
554 -
555 +
556 + case KEYWORD_ALIAS:
557 case KEYWORD_TYPEDEF:
558 reinitStatement (st, FALSE);
559 st->scope = SCOPE_TYPEDEF;
560 @@ -1941,7 +2061,7 @@
561 vStringCat (Signature, token->name);
562 }
563 break;
564 -
565 + case KEYWORD_ALIAS:
566 case KEYWORD_CATCH:
567 case KEYWORD_CLASS:
568 case KEYWORD_EXPLICIT:
569 @@ -2317,6 +2437,10 @@
570 st->gotParenName = TRUE;
571 if (! (c == '(' && info.nestedArgs))
572 st->isPointer = info.isPointer;
573 + //if( c == '(' && isType (prev, TOKEN_NAME)){
574 + // st->declaration = DECL_FUNCTION_TEMPLATE;
575 + // copyToken (st->blockName, prev);
576 + //}
577 }
578 else if (! st->gotArgs && info.isParamList)
579 {
580 @@ -2377,7 +2501,7 @@
581 else
582 {
583 cppUngetc (c);
584 - if ((isLanguage (Lang_cpp) || isLanguage (Lang_csharp)) &&
585 + if ((isLanguage (Lang_cpp) || isLanguage (Lang_csharp) || isLanguage(Lang_d)) &&
586 inheritingDeclaration (st->declaration))
587 {
588 readParents (st, ':');
589 @@ -2641,6 +2765,9 @@
590 {
591 switch (st->declaration)
592 {
593 + case DECL_TEMPLATE:
594 + case DECL_VERSION:
595 + st->inFunction = FALSE;
596 case DECL_CLASS:
597 case DECL_ENUM:
598 case DECL_INTERFACE:
599 @@ -2671,12 +2798,14 @@
600 const tokenInfo *const token = activeToken (st);
601 const tokenInfo *const prev = prevToken (st, 1);
602 const tokenInfo *const prev2 = prevToken (st, 2);
603 -
604 + const tokenInfo *const prev3 = prevToken (st, 3);
605 switch (token->type)
606 {
607 case TOKEN_NAME:
608 if (insideEnumBody (st))
609 qualifyEnumeratorTag (st, token);
610 + if (st->declaration == DECL_MIXIN)
611 + makeTag (token, st, FALSE, TAG_MIXIN);
612 break;
613 #if 0
614 case TOKEN_PACKAGE:
615 @@ -2687,17 +2816,27 @@
616 case TOKEN_BRACE_OPEN:
617 if (isType (prev, TOKEN_ARGS))
618 {
619 - if (st->haveQualifyingName)
620 + if (st->declaration == DECL_TEMPLATE)
621 + qualifyBlockTag (st, prev2);
622 + else if (st->declaration == DECL_FUNCTION_TEMPLATE) {
623 + qualifyFunctionTag (st, st->blockName);
624 + }
625 + else if (st->haveQualifyingName)
626 {
627 - if (! isLanguage (Lang_vera))
628 + if (! isLanguage (Lang_vera) && st->declaration != DECL_CLASS)
629 st->declaration = DECL_FUNCTION;
630 if (isType (prev2, TOKEN_NAME))
631 copyToken (st->blockName, prev2);
632 - qualifyFunctionTag (st, prev2);
633 +
634 + if( st->declaration == DECL_CLASS)
635 + qualifyBlockTag (st, prev2);
636 + else
637 + qualifyFunctionTag (st, prev2);
638 }
639 }
640 else if (isContextualStatement (st) ||
641 st->declaration == DECL_NAMESPACE ||
642 + st->declaration == DECL_VERSION ||
643 st->declaration == DECL_PROGRAM)
644 {
645 if (isType (prev, TOKEN_NAME))
646 @@ -2838,7 +2977,6 @@
647 Lang_c = language;
648 buildKeywordHash (language, 0);
649 }
650 -
651 static void initializeCppParser (const langType language)
652 {
653 Lang_cpp = language;
654 @@ -2851,16 +2989,23 @@
655 buildKeywordHash (language, 2);
656 }
657
658 +static void initializeDParser (const langType language)
659 +{
660 + Lang_d = language;
661 + buildKeywordHash (language, 3);
662 +}
663 +
664 +
665 static void initializeJavaParser (const langType language)
666 {
667 Lang_java = language;
668 - buildKeywordHash (language, 3);
669 + buildKeywordHash (language, 4);
670 }
671
672 static void initializeVeraParser (const langType language)
673 {
674 Lang_vera = language;
675 - buildKeywordHash (language, 4);
676 + buildKeywordHash (language, 5);
677 }
678
679 extern parserDefinition* CParser (void)
680 @@ -2875,6 +3020,18 @@
681 return def;
682 }
683
684 +extern parserDefinition* DParser (void)
685 +{
686 + static const char *const extensions [] = { "d", NULL };
687 + parserDefinition* def = parserNew ("D");
688 + def->kinds = CKinds;
689 + def->kindCount = KIND_COUNT (CKinds);
690 + def->extensions = extensions;
691 + def->parser2 = findCTags;
692 + def->initialize = initializeDParser;
693 + return def;
694 +}
695 +
696 extern parserDefinition* CppParser (void)
697 {
698 static const char *const extensions [] = {
699 Gemeinsame Unterverzeichnisse: ctags-5.8.orig//gnu_regex und ctags-5.8//gnu_regex.
700 diff -u ctags-5.8.orig//parsers.h ctags-5.8//parsers.h
701 --- ctags-5.8.orig//parsers.h 2009-07-07 05:40:51.000000000 +0200
702 +++ ctags-5.8//parsers.h 2010-05-22 02:29:02.777030096 +0200
703 @@ -26,6 +26,7 @@
704 CppParser, \
705 CsharpParser, \
706 CobolParser, \
707 + DParser,\
708 DosBatchParser, \
709 EiffelParser, \
710 ErlangParser, \
711