?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update parser kind mappings
[geany-mirror.git] / src / tagmanager / tm_parser.c
blobb61bb269f8ff30020d0bad43c4844712d49f4a52
1 /*
2 * tm_parser.c - this file is part of Geany, a fast and lightweight IDE
3 *
4 * Copyright 2016 The Geany contributors
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21 #include "tm_parser.h"
22 #include "tm_ctags.h"
23
24 #include <string.h>
25
26 #include "config.h"
27
28
29 #ifdef GETTEXT_PACKAGE
30 # include <glib/gi18n-lib.h>
31 #else
32 # define _(String) String
33 # define N_(String) String
34 #endif
35
36 typedef struct
37 {
38 const gchar kind;
39 TMTagType type;
40 } TMParserMapEntry;
41
42 /* Allows remapping a subparser tag type to another type if there's a clash with
43 * the master parser tag type. Only subparser tag types explicitly listed within
44 * TMSubparserMapEntry maps are added to tag manager - tags with types not listed
45 * are discarded to prevent uncontrolled merging of tags from master parser and
46 * subparsers. */
47 typedef struct
48 {
49 TMTagType orig_type;
50 TMTagType new_type;
51 } TMSubparserMapEntry;
52
53 typedef struct
54 {
55 const gchar *name;
56 guint icon;
57 TMTagType types;
58 } TMParserMapGroup;
59
60 static GHashTable *subparser_map = NULL;
61
62
63 #define COMMON_C \
64 {'d', tm_tag_macro_t}, /* macro */ \
65 {'e', tm_tag_enumerator_t}, /* enumerator */ \
66 {'f', tm_tag_function_t}, /* function */ \
67 {'g', tm_tag_enum_t}, /* enum */ \
68 {'m', tm_tag_member_t}, /* member */ \
69 {'p', tm_tag_prototype_t}, /* prototype */ \
70 {'s', tm_tag_struct_t}, /* struct */ \
71 {'t', tm_tag_typedef_t}, /* typedef */ \
72 {'u', tm_tag_union_t}, /* union */ \
73 {'v', tm_tag_variable_t}, /* variable */ \
74 {'x', tm_tag_externvar_t}, /* externvar */ \
75 {'h', tm_tag_include_t}, /* header */ \
76 {'l', tm_tag_local_var_t}, /* local */ \
77 {'z', tm_tag_local_var_t}, /* parameter */ \
78 {'L', tm_tag_undef_t}, /* label */ \
79 {'D', tm_tag_undef_t}, /* macroparam */
80
81 static TMParserMapEntry map_C[] = {
82 COMMON_C
83 };
84 /* Used also by other languages than C - keep all the tm_tag_* here even though
85 * they aren't used by C as they might be used by some other language */
86 static TMParserMapGroup group_C[] = {
87 {N_("Namespaces"), TM_ICON_NAMESPACE, tm_tag_namespace_t | tm_tag_package_t | tm_tag_include_t},
88 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
89 {N_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
90 {N_("Functions"), TM_ICON_METHOD, tm_tag_prototype_t | tm_tag_method_t | tm_tag_function_t},
91 {N_("Members"), TM_ICON_MEMBER, tm_tag_member_t | tm_tag_field_t},
92 {N_("Structs"), TM_ICON_STRUCT, tm_tag_union_t | tm_tag_struct_t},
93 {N_("Typedefs / Enums"), TM_ICON_STRUCT, tm_tag_typedef_t | tm_tag_enum_t},
94 {N_("Macros"), TM_ICON_MACRO, tm_tag_macro_t | tm_tag_macro_with_arg_t},
95 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_enumerator_t | tm_tag_local_var_t},
96 {N_("Extern Variables"), TM_ICON_VAR, tm_tag_externvar_t},
97 {N_("Other"), TM_ICON_OTHER, tm_tag_other_t},
98 };
99
100 static TMParserMapEntry map_CPP[] = {
101 COMMON_C
102 {'c', tm_tag_class_t}, // class
103 {'n', tm_tag_namespace_t}, // namespace
104 {'A', tm_tag_undef_t}, // alias
105 {'N', tm_tag_undef_t}, // name
106 {'U', tm_tag_undef_t}, // using
107 {'Z', tm_tag_undef_t}, // tparam
108 {'M', tm_tag_undef_t}, // module
109 {'P', tm_tag_undef_t}, // partition
110 };
111 #define group_CPP group_C
112
113 static TMParserMapEntry map_JAVA[] = {
114 {'c', tm_tag_class_t}, // class
115 {'f', tm_tag_field_t}, // field
116 {'i', tm_tag_interface_t}, // interface
117 {'m', tm_tag_method_t}, // method
118 {'p', tm_tag_package_t}, // package
119 {'e', tm_tag_enumerator_t}, // enumConstant
120 {'g', tm_tag_enum_t}, // enum
121 };
122 static TMParserMapGroup group_JAVA[] = {
123 {N_("Package"), TM_ICON_NAMESPACE, tm_tag_package_t},
124 {N_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
125 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
126 {N_("Methods"), TM_ICON_METHOD, tm_tag_method_t},
127 {N_("Members"), TM_ICON_MEMBER, tm_tag_field_t},
128 {N_("Enums"), TM_ICON_STRUCT, tm_tag_enum_t},
129 {N_("Other"), TM_ICON_VAR, tm_tag_enumerator_t},
130 };
131
132 // no scope information
133 static TMParserMapEntry map_MAKEFILE[] = {
134 {'m', tm_tag_macro_t}, // macro
135 {'t', tm_tag_function_t}, // target
136 {'I', tm_tag_undef_t}, // makefile
137 };
138 static TMParserMapGroup group_MAKEFILE[] = {
139 {N_("Targets"), TM_ICON_METHOD, tm_tag_function_t},
140 {N_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
141 };
142
143 static TMParserMapEntry map_PASCAL[] = {
144 {'f', tm_tag_function_t}, // function
145 {'p', tm_tag_function_t}, // procedure
146 };
147 static TMParserMapGroup group_PASCAL[] = {
148 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
149 };
150
151 // no scope information
152 static TMParserMapEntry map_PERL[] = {
153 {'c', tm_tag_enum_t}, // constant
154 {'f', tm_tag_other_t}, // format
155 {'l', tm_tag_macro_t}, // label
156 {'p', tm_tag_package_t}, // package
157 {'s', tm_tag_function_t}, // subroutine
158 {'d', tm_tag_prototype_t}, // subroutineDeclaration
159 {'M', tm_tag_undef_t}, // module
160 {'h', tm_tag_undef_t}, // heredoc
161 };
162 static TMParserMapGroup group_PERL[] = {
163 {N_("Package"), TM_ICON_NAMESPACE, tm_tag_package_t},
164 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_prototype_t},
165 {N_("Labels"), TM_ICON_NONE, tm_tag_macro_t},
166 {N_("Constants"), TM_ICON_NONE, tm_tag_enum_t},
167 {N_("Other"), TM_ICON_OTHER, tm_tag_other_t},
168 };
169
170 static TMParserMapEntry map_PHP[] = {
171 {'c', tm_tag_class_t}, // class
172 {'d', tm_tag_macro_t}, // define
173 {'f', tm_tag_function_t}, // function
174 {'i', tm_tag_interface_t}, // interface
175 {'l', tm_tag_local_var_t}, // local
176 {'n', tm_tag_namespace_t}, // namespace
177 {'t', tm_tag_struct_t}, // trait
178 {'v', tm_tag_variable_t}, // variable
179 {'a', tm_tag_undef_t}, // alias
180 };
181 static TMParserMapGroup group_PHP[] = {
182 {N_("Namespaces"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
183 {N_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
184 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
185 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
186 {N_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
187 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_local_var_t},
188 {N_("Traits"), TM_ICON_STRUCT, tm_tag_struct_t},
189 };
190
191 static TMParserMapEntry map_PYTHON[] = {
192 {'c', tm_tag_class_t}, // class
193 {'f', tm_tag_function_t}, // function
194 {'m', tm_tag_method_t}, // member
195 {'v', tm_tag_variable_t}, // variable
196 {'I', tm_tag_externvar_t}, // namespace
197 {'i', tm_tag_externvar_t}, // module
198 /* defined as externvar to get those excluded as forward type in symbols.c:goto_tag()
199 * so we can jump to the real implementation (if known) instead of to the import statement */
200 {'Y', tm_tag_externvar_t}, // unknown
201 {'z', tm_tag_local_var_t}, // parameter
202 {'l', tm_tag_local_var_t}, // local
203 };
204 static TMParserMapGroup group_PYTHON[] = {
205 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
206 {N_("Methods"), TM_ICON_MACRO, tm_tag_method_t},
207 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
208 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_local_var_t},
209 {N_("Imports"), TM_ICON_NAMESPACE, tm_tag_externvar_t},
210 };
211
212 static TMParserMapEntry map_LATEX[] = {
213 {'p', tm_tag_enum_t}, // part
214 {'c', tm_tag_namespace_t}, // chapter
215 {'s', tm_tag_member_t}, // section
216 {'u', tm_tag_macro_t}, // subsection
217 {'b', tm_tag_variable_t}, // subsubsection
218 {'P', tm_tag_undef_t}, // paragraph
219 {'G', tm_tag_undef_t}, // subparagraph
220 {'l', tm_tag_struct_t}, // label
221 {'i', tm_tag_undef_t}, // xinput
222 {'B', tm_tag_field_t}, // bibitem
223 {'C', tm_tag_function_t}, // command
224 {'o', tm_tag_function_t}, // operator
225 {'e', tm_tag_class_t}, // environment
226 {'t', tm_tag_class_t}, // theorem
227 {'N', tm_tag_undef_t}, // counter
228 };
229 static TMParserMapGroup group_LATEX[] = {
230 {N_("Command"), TM_ICON_NONE, tm_tag_function_t},
231 {N_("Environment"), TM_ICON_NONE, tm_tag_class_t},
232 {N_("Part"), TM_ICON_NONE, tm_tag_enum_t},
233 {N_("Chapter"), TM_ICON_NONE, tm_tag_namespace_t},
234 {N_("Section"), TM_ICON_NONE, tm_tag_member_t},
235 {N_("Subsection"), TM_ICON_NONE, tm_tag_macro_t},
236 {N_("Subsubsection"), TM_ICON_NONE, tm_tag_variable_t},
237 {N_("Bibitem"), TM_ICON_NONE, tm_tag_field_t},
238 {N_("Label"), TM_ICON_NONE, tm_tag_struct_t},
239 };
240
241 // no scope information
242 static TMParserMapEntry map_BIBTEX[] = {
243 {'a', tm_tag_function_t}, // article
244 {'b', tm_tag_class_t}, // book
245 {'B', tm_tag_class_t}, // booklet
246 {'c', tm_tag_member_t}, // conference
247 {'i', tm_tag_macro_t}, // inbook
248 {'I', tm_tag_macro_t}, // incollection
249 {'j', tm_tag_member_t}, // inproceedings
250 {'m', tm_tag_other_t}, // manual
251 {'M', tm_tag_variable_t}, // mastersthesis
252 {'n', tm_tag_other_t}, // misc
253 {'p', tm_tag_variable_t}, // phdthesis
254 {'P', tm_tag_class_t}, // proceedings
255 {'s', tm_tag_namespace_t}, // string
256 {'t', tm_tag_other_t}, // techreport
257 {'u', tm_tag_externvar_t}, // unpublished
258 };
259 static TMParserMapGroup group_BIBTEX[] = {
260 {N_("Articles"), TM_ICON_NONE, tm_tag_function_t},
261 {N_("Book Chapters"), TM_ICON_NONE, tm_tag_macro_t},
262 {N_("Books & Conference Proceedings"), TM_ICON_NONE, tm_tag_class_t},
263 {N_("Conference Papers"), TM_ICON_NONE, tm_tag_member_t},
264 {N_("Theses"), TM_ICON_NONE, tm_tag_variable_t},
265 {N_("Strings"), TM_ICON_NONE, tm_tag_namespace_t},
266 {N_("Unpublished"), TM_ICON_NONE, tm_tag_externvar_t},
267 {N_("Other"), TM_ICON_NONE, tm_tag_other_t},
268 };
269
270 static TMParserMapEntry map_ASM[] = {
271 {'d', tm_tag_macro_t}, // define
272 {'l', tm_tag_namespace_t}, // label
273 {'m', tm_tag_function_t}, // macro
274 {'t', tm_tag_struct_t}, // type
275 {'z', tm_tag_undef_t}, // parameter
276 };
277 static TMParserMapGroup group_ASM[] = {
278 {N_("Labels"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
279 {N_("Macros"), TM_ICON_METHOD, tm_tag_function_t},
280 {N_("Defines"), TM_ICON_MACRO, tm_tag_macro_t},
281 {N_("Types"), TM_ICON_STRUCT, tm_tag_struct_t},
282 };
283
284 static TMParserMapEntry map_CONF[] = {
285 {'s', tm_tag_namespace_t}, // section
286 {'k', tm_tag_macro_t}, // key
287 };
288 static TMParserMapGroup group_CONF[] = {
289 {N_("Sections"), TM_ICON_OTHER, tm_tag_namespace_t},
290 {N_("Keys"), TM_ICON_VAR, tm_tag_macro_t},
291 };
292
293 static TMParserMapEntry map_SQL[] = {
294 {'C', tm_tag_undef_t}, // ccflag
295 {'D', tm_tag_undef_t}, // domain
296 {'E', tm_tag_field_t}, // field
297 {'L', tm_tag_undef_t}, // label
298 {'P', tm_tag_package_t}, // package
299 {'R', tm_tag_undef_t}, // service
300 {'S', tm_tag_undef_t}, // schema
301 {'T', tm_tag_macro_t}, // trigger
302 {'U', tm_tag_undef_t}, // publication
303 {'V', tm_tag_member_t}, // view
304 {'b', tm_tag_undef_t}, // database
305 {'c', tm_tag_undef_t}, // cursor
306 {'d', tm_tag_prototype_t}, // prototype
307 {'e', tm_tag_undef_t}, // event
308 {'f', tm_tag_function_t}, // function
309 {'i', tm_tag_struct_t}, // index
310 {'l', tm_tag_undef_t}, // local
311 {'n', tm_tag_undef_t}, // synonym
312 {'p', tm_tag_namespace_t}, // procedure
313 {'r', tm_tag_undef_t}, // record
314 {'s', tm_tag_undef_t}, // subtype
315 {'t', tm_tag_class_t}, // table
316 {'v', tm_tag_variable_t}, // variable
317 {'x', tm_tag_undef_t}, // mltable
318 {'y', tm_tag_undef_t}, // mlconn
319 {'z', tm_tag_undef_t}, // mlprop
320 };
321 static TMParserMapGroup group_SQL[] = {
322 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_prototype_t},
323 {N_("Procedures"), TM_ICON_NAMESPACE, tm_tag_namespace_t | tm_tag_package_t},
324 {N_("Indexes"), TM_ICON_STRUCT, tm_tag_struct_t},
325 {N_("Tables"), TM_ICON_CLASS, tm_tag_class_t},
326 {N_("Triggers"), TM_ICON_MACRO, tm_tag_macro_t},
327 {N_("Views"), TM_ICON_VAR, tm_tag_field_t | tm_tag_member_t},
328 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
329 };
330
331 static TMParserMapEntry map_DOCBOOK[] = {
332 {'f', tm_tag_function_t},
333 {'c', tm_tag_class_t},
334 {'m', tm_tag_member_t},
335 {'d', tm_tag_macro_t},
336 {'v', tm_tag_variable_t},
337 {'s', tm_tag_struct_t},
338 };
339 static TMParserMapGroup group_DOCBOOK[] = {
340 {N_("Chapter"), TM_ICON_NONE, tm_tag_function_t},
341 {N_("Section"), TM_ICON_NONE, tm_tag_class_t},
342 {N_("Sect1"), TM_ICON_NONE, tm_tag_member_t},
343 {N_("Sect2"), TM_ICON_NONE, tm_tag_macro_t},
344 {N_("Sect3"), TM_ICON_NONE, tm_tag_variable_t},
345 {N_("Appendix"), TM_ICON_NONE, tm_tag_struct_t},
346 };
347
348 // no scope information
349 static TMParserMapEntry map_ERLANG[] = {
350 {'d', tm_tag_macro_t}, // macro
351 {'f', tm_tag_function_t}, // function
352 {'m', tm_tag_namespace_t}, // module
353 {'r', tm_tag_struct_t}, // record
354 {'t', tm_tag_typedef_t}, // type
355 };
356 static TMParserMapGroup group_ERLANG[] = {
357 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
358 {N_("Structs"), TM_ICON_STRUCT, tm_tag_struct_t},
359 {N_("Typedefs / Enums"), TM_ICON_STRUCT, tm_tag_typedef_t},
360 {N_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
361 {N_("Module"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
362 };
363
364 // no scope information
365 static TMParserMapEntry map_CSS[] = {
366 {'c', tm_tag_class_t}, // class
367 {'s', tm_tag_struct_t}, // selector
368 {'i', tm_tag_variable_t}, // id
369 };
370 static TMParserMapGroup group_CSS[] = {
371 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
372 {N_("ID Selectors"), TM_ICON_VAR, tm_tag_variable_t},
373 {N_("Type Selectors"), TM_ICON_STRUCT, tm_tag_struct_t},
374 };
375
376 static TMParserMapEntry map_RUBY[] = {
377 {'c', tm_tag_class_t}, // class
378 {'f', tm_tag_method_t}, // method
379 {'m', tm_tag_namespace_t}, // module
380 {'S', tm_tag_member_t}, // singletonMethod
381 {'C', tm_tag_undef_t}, // constant
382 {'A', tm_tag_undef_t}, // accessor
383 {'a', tm_tag_undef_t}, // alias
384 {'L', tm_tag_undef_t}, // library
385 };
386 static TMParserMapGroup group_RUBY[] = {
387 {N_("Modules"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
388 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
389 {N_("Singletons"), TM_ICON_STRUCT, tm_tag_member_t},
390 {N_("Methods"), TM_ICON_METHOD, tm_tag_method_t},
391 };
392
393 static TMParserMapEntry map_TCL[] = {
394 {'p', tm_tag_function_t}, // procedure
395 {'n', tm_tag_namespace_t}, // namespace
396 {'z', tm_tag_undef_t}, // parameter
397 };
398 static TMParserMapGroup group_TCL[] = {
399 {N_("Namespaces"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
400 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
401 {N_("Methods"), TM_ICON_METHOD, tm_tag_member_t},
402 {N_("Procedures"), TM_ICON_OTHER, tm_tag_function_t},
403 };
404
405 static TMParserMapEntry map_TCLOO[] = {
406 {'c', tm_tag_class_t}, // class
407 {'m', tm_tag_member_t}, // method
408 };
409 #define group_TCLOO group_TCL
410
411 static TMSubparserMapEntry subparser_TCLOO_TCL_map[] = {
412 {tm_tag_namespace_t, tm_tag_namespace_t},
413 {tm_tag_class_t, tm_tag_class_t},
414 {tm_tag_member_t, tm_tag_member_t},
415 {tm_tag_function_t, tm_tag_function_t},
416 };
417
418 static TMParserMapEntry map_SH[] = {
419 {'a', tm_tag_undef_t}, // alias
420 {'f', tm_tag_function_t}, // function
421 {'s', tm_tag_undef_t}, // script
422 {'h', tm_tag_undef_t}, // heredoc
423 };
424 static TMParserMapGroup group_SH[] = {
425 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
426 };
427
428 static TMParserMapEntry map_D[] = {
429 {'c', tm_tag_class_t}, // class
430 {'e', tm_tag_enumerator_t}, // enumerator
431 {'f', tm_tag_function_t}, // function
432 {'g', tm_tag_enum_t}, // enum
433 {'i', tm_tag_interface_t}, // interface
434 {'m', tm_tag_member_t}, // member
435 {'n', tm_tag_namespace_t}, // namespace
436 {'p', tm_tag_prototype_t}, // prototype
437 {'s', tm_tag_struct_t}, // struct
438 {'t', tm_tag_typedef_t}, // typedef
439 {'u', tm_tag_union_t}, // union
440 {'v', tm_tag_variable_t}, // variable
441 {'x', tm_tag_externvar_t}, // externvar
442 };
443 static TMParserMapGroup group_D[] = {
444 {N_("Module"), TM_ICON_NONE, tm_tag_namespace_t},
445 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
446 {N_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
447 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_prototype_t},
448 {N_("Members"), TM_ICON_MEMBER, tm_tag_member_t},
449 {N_("Structs"), TM_ICON_STRUCT, tm_tag_struct_t | tm_tag_union_t},
450 {N_("Typedefs / Enums"), TM_ICON_STRUCT, tm_tag_typedef_t | tm_tag_enum_t},
451 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_enumerator_t},
452 {N_("Extern Variables"), TM_ICON_VAR, tm_tag_externvar_t},
453 };
454
455 static TMParserMapEntry map_DIFF[] = {
456 {'m', tm_tag_function_t}, // modifiedFile
457 {'n', tm_tag_function_t}, // newFile
458 {'d', tm_tag_function_t}, // deletedFile
459 {'h', tm_tag_undef_t}, // hunk
460 };
461 static TMParserMapGroup group_DIFF[] = {
462 {N_("Files"), TM_ICON_NONE, tm_tag_function_t},
463 };
464
465 static TMParserMapEntry map_VHDL[] = {
466 {'c', tm_tag_variable_t}, // constant
467 {'t', tm_tag_typedef_t}, // type
468 {'T', tm_tag_typedef_t}, // subtype
469 {'r', tm_tag_undef_t}, // record
470 {'e', tm_tag_class_t}, // entity
471 {'C', tm_tag_member_t}, // component
472 {'d', tm_tag_undef_t}, // prototype
473 {'f', tm_tag_function_t}, // function
474 {'p', tm_tag_function_t}, // procedure
475 {'P', tm_tag_namespace_t}, // package
476 {'l', tm_tag_variable_t}, // local
477 {'a', tm_tag_struct_t}, // architecture
478 {'q', tm_tag_variable_t}, // port
479 {'g', tm_tag_undef_t}, // generic
480 {'s', tm_tag_variable_t}, // signal
481 {'Q', tm_tag_member_t}, // process
482 {'v', tm_tag_variable_t}, // variable
483 {'A', tm_tag_typedef_t}, // alias
484 };
485 static TMParserMapGroup group_VHDL[] = {
486 {N_("Package"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
487 {N_("Entities"), TM_ICON_CLASS, tm_tag_class_t},
488 {N_("Architectures"), TM_ICON_STRUCT, tm_tag_struct_t},
489 {N_("Types"), TM_ICON_OTHER, tm_tag_typedef_t},
490 {N_("Functions / Procedures"), TM_ICON_METHOD, tm_tag_function_t},
491 {N_("Variables / Signals / Ports"), TM_ICON_VAR, tm_tag_variable_t},
492 {N_("Processes / Blocks / Components"), TM_ICON_MEMBER, tm_tag_member_t},
493 };
494
495 static TMParserMapEntry map_LUA[] = {
496 {'f', tm_tag_function_t}, // function
497 {'Y', tm_tag_undef_t}, // unknown
498 };
499 static TMParserMapGroup group_LUA[] = {
500 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
501 };
502
503 static TMParserMapEntry map_JAVASCRIPT[] = {
504 {'f', tm_tag_function_t}, // function
505 {'c', tm_tag_class_t}, // class
506 {'m', tm_tag_method_t}, // method
507 {'p', tm_tag_member_t}, // property
508 {'C', tm_tag_macro_t}, // constant
509 {'v', tm_tag_variable_t}, // variable
510 {'g', tm_tag_function_t}, // generator
511 {'G', tm_tag_undef_t}, // getter
512 {'S', tm_tag_undef_t}, // setter
513 {'M', tm_tag_undef_t}, // field
514 };
515 static TMParserMapGroup group_JAVASCRIPT[] = {
516 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
517 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_method_t},
518 {N_("Members"), TM_ICON_MEMBER, tm_tag_member_t},
519 {N_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
520 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
521 };
522
523 // no scope information
524 static TMParserMapEntry map_HASKELL[] = {
525 {'t', tm_tag_typedef_t}, // type
526 {'c', tm_tag_macro_t}, // constructor
527 {'f', tm_tag_function_t}, // function
528 {'m', tm_tag_namespace_t}, // module
529 };
530 static TMParserMapGroup group_HASKELL[] = {
531 {N_("Module"), TM_ICON_NONE, tm_tag_namespace_t},
532 {N_("Types"), TM_ICON_NONE, tm_tag_typedef_t},
533 {N_("Type constructors"), TM_ICON_NONE, tm_tag_macro_t},
534 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
535 };
536
537 #define map_UNUSED1 map_HASKELL
538 #define group_UNUSED1 group_HASKELL
539
540 static TMParserMapEntry map_CSHARP[] = {
541 {'c', tm_tag_class_t}, // class
542 {'d', tm_tag_macro_t}, // macro
543 {'e', tm_tag_enumerator_t}, // enumerator
544 {'E', tm_tag_undef_t}, // event
545 {'f', tm_tag_field_t}, // field
546 {'g', tm_tag_enum_t}, // enum
547 {'i', tm_tag_interface_t}, // interface
548 {'l', tm_tag_undef_t}, // local
549 {'m', tm_tag_method_t}, // method
550 {'n', tm_tag_namespace_t}, // namespace
551 {'p', tm_tag_undef_t}, // property
552 {'s', tm_tag_struct_t}, // struct
553 {'t', tm_tag_typedef_t}, // typedef
554 };
555 #define group_CSHARP group_C
556
557 // no scope information
558 static TMParserMapEntry map_FREEBASIC[] = {
559 {'c', tm_tag_macro_t}, // constant
560 {'f', tm_tag_function_t}, // function
561 {'l', tm_tag_namespace_t}, // label
562 {'t', tm_tag_struct_t}, // type
563 {'v', tm_tag_variable_t}, // variable
564 {'g', tm_tag_externvar_t}, // enum
565 {'n', tm_tag_undef_t}, // namespace
566 };
567 static TMParserMapGroup group_FREEBASIC[] = {
568 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
569 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_externvar_t},
570 {N_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
571 {N_("Types"), TM_ICON_NAMESPACE, tm_tag_struct_t},
572 {N_("Labels"), TM_ICON_MEMBER, tm_tag_namespace_t},
573 };
574
575 // no scope information
576 static TMParserMapEntry map_HAXE[] = {
577 {'m', tm_tag_method_t}, // method
578 {'c', tm_tag_class_t}, // class
579 {'e', tm_tag_enum_t}, // enum
580 {'v', tm_tag_variable_t}, // variable
581 {'i', tm_tag_interface_t}, // interface
582 {'t', tm_tag_typedef_t}, // typedef
583 };
584 static TMParserMapGroup group_HAXE[] = {
585 {N_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
586 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
587 {N_("Methods"), TM_ICON_METHOD, tm_tag_method_t},
588 {N_("Types"), TM_ICON_MACRO, tm_tag_typedef_t | tm_tag_enum_t},
589 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
590 };
591
592 static TMParserMapEntry map_REST[] = {
593 {'H', tm_tag_undef_t}, // title
594 {'h', tm_tag_undef_t}, // subtitle
595 {'c', tm_tag_namespace_t}, // chapter
596 {'s', tm_tag_member_t}, // section
597 {'S', tm_tag_macro_t}, // subsection
598 {'t', tm_tag_variable_t}, // subsubsection
599 {'C', tm_tag_undef_t}, // citation
600 {'T', tm_tag_undef_t}, // target
601 {'d', tm_tag_undef_t}, // substdef
602 };
603 static TMParserMapGroup group_REST[] = {
604 {N_("Chapter"), TM_ICON_NONE, tm_tag_namespace_t},
605 {N_("Section"), TM_ICON_NONE, tm_tag_member_t},
606 {N_("Subsection"), TM_ICON_NONE, tm_tag_macro_t},
607 {N_("Subsubsection"), TM_ICON_NONE, tm_tag_variable_t},
608 };
609
610 // no scope information
611 static TMParserMapEntry map_HTML[] = {
612 {'a', tm_tag_member_t}, // anchor
613 {'c', tm_tag_undef_t}, // class
614 {'t', tm_tag_undef_t}, // title
615 {'h', tm_tag_namespace_t}, // heading1
616 {'i', tm_tag_class_t}, // heading2
617 {'j', tm_tag_variable_t}, // heading3
618 {'C', tm_tag_undef_t}, // stylesheet
619 {'I', tm_tag_undef_t}, // id
620 {'J', tm_tag_undef_t}, // script
621 };
622 static TMParserMapGroup group_HTML[] = {
623 {N_("Functions"), TM_ICON_NONE, tm_tag_function_t}, // javascript functions from subparser
624 {N_("Anchors"), TM_ICON_NONE, tm_tag_member_t},
625 {N_("H1 Headings"), TM_ICON_NONE, tm_tag_namespace_t},
626 {N_("H2 Headings"), TM_ICON_NONE, tm_tag_class_t},
627 {N_("H3 Headings"), TM_ICON_NONE, tm_tag_variable_t},
628 };
629
630 static TMSubparserMapEntry subparser_HTML_javascript_map[] = {
631 {tm_tag_function_t, tm_tag_function_t},
632 };
633
634 static TMParserMapEntry map_FORTRAN[] = {
635 {'b', tm_tag_undef_t}, // blockData
636 {'c', tm_tag_macro_t}, // common
637 {'e', tm_tag_undef_t}, // entry
638 {'E', tm_tag_enum_t}, // enum
639 {'f', tm_tag_function_t}, // function
640 {'i', tm_tag_interface_t}, // interface
641 {'k', tm_tag_member_t}, // component
642 {'l', tm_tag_undef_t}, // label
643 {'L', tm_tag_undef_t}, // local
644 {'m', tm_tag_namespace_t}, // module
645 {'M', tm_tag_member_t}, // method
646 {'n', tm_tag_undef_t}, // namelist
647 {'N', tm_tag_enumerator_t}, // enumerator
648 {'p', tm_tag_struct_t}, // program
649 {'P', tm_tag_undef_t}, // prototype
650 {'s', tm_tag_method_t}, // subroutine
651 {'t', tm_tag_class_t}, // type
652 {'v', tm_tag_variable_t}, // variable
653 {'S', tm_tag_undef_t}, // submodule
654 };
655 static TMParserMapGroup group_FORTRAN[] = {
656 {N_("Module"), TM_ICON_CLASS, tm_tag_namespace_t},
657 {N_("Programs"), TM_ICON_CLASS, tm_tag_struct_t},
658 {N_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
659 {N_("Functions / Subroutines"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_method_t},
660 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_enumerator_t},
661 {N_("Types"), TM_ICON_CLASS, tm_tag_class_t},
662 {N_("Components"), TM_ICON_MEMBER, tm_tag_member_t},
663 {N_("Blocks"), TM_ICON_MEMBER, tm_tag_macro_t},
664 {N_("Enums"), TM_ICON_STRUCT, tm_tag_enum_t},
665 };
666
667 static TMParserMapEntry map_MATLAB[] = {
668 {'f', tm_tag_function_t}, // function
669 {'s', tm_tag_struct_t}, // struct
670 };
671 static TMParserMapGroup group_MATLAB[] = {
672 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
673 {N_("Structures"), TM_ICON_STRUCT, tm_tag_struct_t},
674 };
675
676 #define map_CUDA map_C
677 #define group_CUDA group_C
678
679 static TMParserMapEntry map_VALA[] = {
680 {'c', tm_tag_class_t}, // class
681 {'d', tm_tag_macro_t}, // macro
682 {'e', tm_tag_enumerator_t}, // enumerator
683 {'f', tm_tag_field_t}, // field
684 {'g', tm_tag_enum_t}, // enum
685 {'i', tm_tag_interface_t}, // interface
686 {'l', tm_tag_undef_t}, // local
687 {'m', tm_tag_method_t}, // method
688 {'n', tm_tag_namespace_t}, // namespace
689 {'p', tm_tag_undef_t}, // property
690 {'S', tm_tag_undef_t}, // signal
691 {'s', tm_tag_struct_t}, // struct
692 };
693 #define group_VALA group_C
694
695 static TMParserMapEntry map_ACTIONSCRIPT[] = {
696 {'f', tm_tag_function_t}, // function
697 {'c', tm_tag_class_t}, // class
698 {'i', tm_tag_interface_t}, // interface
699 {'P', tm_tag_package_t}, // package
700 {'m', tm_tag_method_t}, // method
701 {'p', tm_tag_member_t}, // property
702 {'v', tm_tag_variable_t}, // variable
703 {'l', tm_tag_variable_t}, // localvar
704 {'C', tm_tag_macro_t}, // constant
705 {'I', tm_tag_externvar_t}, // import
706 {'x', tm_tag_other_t}, // mxtag
707 };
708 static TMParserMapGroup group_ACTIONSCRIPT[] = {
709 {N_("Imports"), TM_ICON_NAMESPACE, tm_tag_externvar_t},
710 {N_("Package"), TM_ICON_NAMESPACE, tm_tag_package_t},
711 {N_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
712 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
713 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t| tm_tag_method_t},
714 {N_("Properties"), TM_ICON_MEMBER, tm_tag_member_t},
715 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
716 {N_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
717 {N_("Other"), TM_ICON_OTHER, tm_tag_other_t},
718 };
719
720 static TMParserMapEntry map_NSIS[] = {
721 {'s', tm_tag_namespace_t}, // section
722 {'f', tm_tag_function_t}, // function
723 {'v', tm_tag_variable_t}, // variable
724 {'d', tm_tag_undef_t}, // definition
725 {'m', tm_tag_undef_t}, // macro
726 {'S', tm_tag_undef_t}, // sectionGroup
727 {'p', tm_tag_undef_t}, // macroparam
728 {'l', tm_tag_undef_t}, // langstr
729 {'i', tm_tag_undef_t}, // script
730 };
731 static TMParserMapGroup group_NSIS[] = {
732 {N_("Sections"), TM_ICON_OTHER, tm_tag_namespace_t},
733 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
734 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
735 };
736
737 static TMParserMapEntry map_MARKDOWN[] = {
738 {'c', tm_tag_namespace_t}, //chapter
739 {'s', tm_tag_member_t}, //section
740 {'S', tm_tag_macro_t}, //subsection
741 {'t', tm_tag_variable_t}, //subsubsection
742 {'T', tm_tag_struct_t}, //l4subsection
743 {'u', tm_tag_union_t}, //l5subsection
744 {'n', tm_tag_undef_t}, //footnote
745 {'h', tm_tag_undef_t}, //hashtag
746 };
747 static TMParserMapGroup group_MARKDOWN[] = {
748 {N_("Chapters"), TM_ICON_NONE, tm_tag_namespace_t},
749 {N_("Sections"), TM_ICON_NONE, tm_tag_member_t},
750 {N_("Subsections"), TM_ICON_NONE, tm_tag_macro_t},
751 {N_("Subsubsections"), TM_ICON_NONE, tm_tag_variable_t},
752 {N_("Level 4 sections"), TM_ICON_NONE, tm_tag_struct_t},
753 {N_("Level 5 sections"), TM_ICON_NONE, tm_tag_union_t},
754 };
755
756 static TMParserMapEntry map_TXT2TAGS[] = {
757 {'s', tm_tag_member_t}, // section
758 };
759 #define group_TXT2TAGS group_REST
760
761 // no scope information
762 static TMParserMapEntry map_ABC[] = {
763 {'s', tm_tag_member_t}, // section
764 };
765 #define group_ABC group_REST
766
767 static TMParserMapEntry map_VERILOG[] = {
768 {'c', tm_tag_variable_t}, // constant
769 {'d', tm_tag_undef_t}, // define
770 {'e', tm_tag_typedef_t}, // event
771 {'f', tm_tag_function_t}, // function
772 {'m', tm_tag_class_t}, // module
773 {'n', tm_tag_variable_t}, // net
774 {'p', tm_tag_variable_t}, // port
775 {'r', tm_tag_variable_t}, // register
776 {'t', tm_tag_function_t}, // task
777 {'b', tm_tag_undef_t}, // block
778 {'i', tm_tag_undef_t}, // instance
779 };
780 static TMParserMapGroup group_VERILOG[] = {
781 {N_("Events"), TM_ICON_MACRO, tm_tag_typedef_t},
782 {N_("Modules"), TM_ICON_CLASS, tm_tag_class_t},
783 {N_("Functions / Tasks"), TM_ICON_METHOD, tm_tag_function_t},
784 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
785 };
786
787 static TMParserMapEntry map_R[] = {
788 {'f', tm_tag_function_t}, // function
789 {'l', tm_tag_other_t}, // library
790 {'s', tm_tag_other_t}, // source
791 {'g', tm_tag_undef_t}, // globalVar
792 {'v', tm_tag_undef_t}, // functionVar
793 {'z', tm_tag_undef_t}, // parameter
794 {'c', tm_tag_undef_t}, // vector
795 {'L', tm_tag_undef_t}, // list
796 {'d', tm_tag_undef_t}, // dataframe
797 {'n', tm_tag_undef_t}, // nameattr
798 };
799 static TMParserMapGroup group_R[] = {
800 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
801 {N_("Other"), TM_ICON_NONE, tm_tag_other_t},
802 };
803
804 static TMParserMapEntry map_COBOL[] = {
805 {'f', tm_tag_function_t}, // fd
806 {'g', tm_tag_struct_t}, // group
807 {'P', tm_tag_class_t}, // program
808 {'s', tm_tag_namespace_t}, // section
809 {'D', tm_tag_interface_t}, // division
810 {'p', tm_tag_macro_t}, // paragraph
811 {'d', tm_tag_variable_t}, // data
812 {'S', tm_tag_externvar_t}, // sourcefile
813 };
814 static TMParserMapGroup group_COBOL[] = {
815 {N_("Program"), TM_ICON_CLASS, tm_tag_class_t},
816 {N_("File"), TM_ICON_METHOD, tm_tag_function_t},
817 {N_("Divisions"), TM_ICON_NAMESPACE, tm_tag_interface_t},
818 {N_("Sections"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
819 {N_("Paragraph"), TM_ICON_OTHER, tm_tag_macro_t},
820 {N_("Group"), TM_ICON_STRUCT, tm_tag_struct_t},
821 {N_("Data"), TM_ICON_VAR, tm_tag_variable_t},
822 {N_("Copies"), TM_ICON_NAMESPACE, tm_tag_externvar_t},
823 };
824
825 static TMParserMapEntry map_OBJC[] = {
826 {'i', tm_tag_interface_t}, // interface
827 {'I', tm_tag_undef_t}, // implementation
828 {'P', tm_tag_undef_t}, // protocol
829 {'m', tm_tag_method_t}, // method
830 {'c', tm_tag_class_t}, // class
831 {'v', tm_tag_variable_t}, // var
832 {'E', tm_tag_field_t}, // field
833 {'f', tm_tag_function_t}, // function
834 {'p', tm_tag_undef_t}, // property
835 {'t', tm_tag_typedef_t}, // typedef
836 {'s', tm_tag_struct_t}, // struct
837 {'e', tm_tag_enum_t}, // enum
838 {'M', tm_tag_macro_t}, // macro
839 {'C', tm_tag_undef_t}, // category
840 };
841 #define group_OBJC group_C
842
843 static TMParserMapEntry map_ASCIIDOC[] = {
844 {'c', tm_tag_namespace_t}, //chapter
845 {'s', tm_tag_member_t}, //section
846 {'S', tm_tag_macro_t}, //subsection
847 {'t', tm_tag_variable_t}, //subsubsection
848 {'T', tm_tag_struct_t}, //l4subsection
849 {'u', tm_tag_enumerator_t}, //l5subsection
850 {'a', tm_tag_undef_t}, //anchor
851 };
852 static TMParserMapGroup group_ASCIIDOC[] = {
853 {N_("Document"), TM_ICON_NONE, tm_tag_namespace_t},
854 {N_("Section Level 1"), TM_ICON_NONE, tm_tag_member_t},
855 {N_("Section Level 2"), TM_ICON_NONE, tm_tag_macro_t},
856 {N_("Section Level 3"), TM_ICON_NONE, tm_tag_variable_t},
857 {N_("Section Level 4"), TM_ICON_NONE, tm_tag_struct_t},
858 {N_("Section Level 5"), TM_ICON_NONE, tm_tag_enumerator_t},
859 };
860
861 // no scope information
862 static TMParserMapEntry map_ABAQUS[] = {
863 {'p', tm_tag_class_t}, // part
864 {'a', tm_tag_member_t}, // assembly
865 {'s', tm_tag_interface_t}, // step
866 };
867 static TMParserMapGroup group_ABAQUS[] = {
868 {N_("Parts"), TM_ICON_NONE, tm_tag_class_t},
869 {N_("Assembly"), TM_ICON_NONE, tm_tag_member_t},
870 {N_("Steps"), TM_ICON_NONE, tm_tag_interface_t},
871 };
872
873 static TMParserMapEntry map_RUST[] = {
874 {'n', tm_tag_namespace_t}, // module
875 {'s', tm_tag_struct_t}, // struct
876 {'i', tm_tag_interface_t}, // interface
877 {'c', tm_tag_class_t}, // implementation
878 {'f', tm_tag_function_t}, // function
879 {'g', tm_tag_enum_t}, // enum
880 {'t', tm_tag_typedef_t}, // typedef
881 {'v', tm_tag_variable_t}, // variable
882 {'M', tm_tag_macro_t}, // macro
883 {'m', tm_tag_field_t}, // field
884 {'e', tm_tag_enumerator_t}, // enumerator
885 {'P', tm_tag_method_t}, // method
886 {'C', tm_tag_undef_t}, // constant
887 };
888 static TMParserMapGroup group_RUST[] = {
889 {N_("Modules"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
890 {N_("Structures"), TM_ICON_STRUCT, tm_tag_struct_t},
891 {N_("Traits"), TM_ICON_CLASS, tm_tag_interface_t},
892 {N_("Implementations"), TM_ICON_CLASS, tm_tag_class_t},
893 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_method_t},
894 {N_("Typedefs / Enums"), TM_ICON_STRUCT, tm_tag_typedef_t | tm_tag_enum_t},
895 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_enumerator_t},
896 {N_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
897 {N_("Methods"), TM_ICON_MEMBER, tm_tag_field_t},
898 };
899
900 static TMParserMapEntry map_GO[] = {
901 {'p', tm_tag_namespace_t}, // package
902 {'f', tm_tag_function_t}, // func
903 {'c', tm_tag_macro_t}, // const
904 {'t', tm_tag_typedef_t}, // type
905 {'v', tm_tag_variable_t}, // var
906 {'s', tm_tag_struct_t}, // struct
907 {'i', tm_tag_interface_t}, // interface
908 {'m', tm_tag_member_t}, // member
909 {'M', tm_tag_undef_t}, // anonMember
910 {'n', tm_tag_undef_t}, // methodSpec
911 {'Y', tm_tag_undef_t}, // unknown
912 {'P', tm_tag_undef_t}, // packageName
913 {'a', tm_tag_undef_t}, // talias
914 {'R', tm_tag_undef_t}, // receiver
915 };
916 static TMParserMapGroup group_GO[] = {
917 {N_("Package"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
918 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
919 {N_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
920 {N_("Structs"), TM_ICON_STRUCT, tm_tag_struct_t},
921 {N_("Types"), TM_ICON_STRUCT, tm_tag_typedef_t},
922 {N_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
923 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
924 {N_("Members"), TM_ICON_MEMBER, tm_tag_member_t},
925 };
926
927 static TMParserMapEntry map_JSON[] = {
928 {'o', tm_tag_member_t}, // object
929 {'a', tm_tag_member_t}, // array
930 {'n', tm_tag_member_t}, // number
931 {'s', tm_tag_member_t}, // string
932 {'b', tm_tag_member_t}, // boolean
933 {'z', tm_tag_member_t}, // null
934 };
935 static TMParserMapGroup group_JSON[] = {
936 {N_("Members"), TM_ICON_MEMBER, tm_tag_member_t},
937 };
938
939 /* Zephir, same as PHP */
940 #define map_ZEPHIR map_PHP
941 #define group_ZEPHIR group_PHP
942
943 static TMParserMapEntry map_POWERSHELL[] = {
944 {'f', tm_tag_function_t}, // function
945 {'v', tm_tag_variable_t}, // variable
946 {'c', tm_tag_undef_t}, // class
947 {'i', tm_tag_undef_t}, // filter
948 {'g', tm_tag_undef_t}, // enum
949 };
950 static TMParserMapGroup group_POWERSHELL[] = {
951 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
952 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
953 };
954
955 static TMParserMapEntry map_JULIA[] = {
956 {'c', tm_tag_variable_t}, // constant
957 {'f', tm_tag_function_t}, // function
958 {'g', tm_tag_member_t}, // field
959 {'m', tm_tag_macro_t}, // macro
960 {'n', tm_tag_namespace_t}, // module
961 {'s', tm_tag_struct_t}, // struct
962 {'t', tm_tag_typedef_t}, // type
963 /* defined as externvar to get those excluded as forward type in symbols.c:goto_tag()
964 * so we can jump to the real implementation (if known) instead of to the import statement */
965 {'Y', tm_tag_externvar_t}, // unknown
966 };
967 static TMParserMapGroup group_JULIA[] = {
968 {N_("Constants"), TM_ICON_VAR, tm_tag_variable_t},
969 {N_("Modules"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
970 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
971 {N_("Fields"), TM_ICON_MEMBER, tm_tag_member_t},
972 {N_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
973 {N_("Structures"), TM_ICON_STRUCT, tm_tag_struct_t},
974 {N_("Types"), TM_ICON_CLASS, tm_tag_typedef_t},
975 {N_("Unknowns"), TM_ICON_OTHER, tm_tag_externvar_t},
976 };
977
978 static TMParserMapEntry map_CPREPROCESSOR[] = {
979 {'d', tm_tag_undef_t}, // macro
980 {'h', tm_tag_undef_t}, // header
981 {'D', tm_tag_undef_t}, // parameter
982 };
983 #define group_CPREPROCESSOR group_C
984
985 static TMParserMapEntry map_GDSCRIPT[] = {
986 {'c', tm_tag_class_t}, // class
987 {'m', tm_tag_method_t}, // method
988 {'v', tm_tag_variable_t}, // variable
989 {'C', tm_tag_variable_t}, // const
990 {'g', tm_tag_enum_t}, // enum
991 {'e', tm_tag_variable_t}, // enumerator
992 {'z', tm_tag_local_var_t}, // parameter
993 {'l', tm_tag_local_var_t}, // local
994 {'s', tm_tag_variable_t}, // signal
995 };
996 static TMParserMapGroup group_GDSCRIPT[] = {
997 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
998 {N_("Methods"), TM_ICON_MACRO, tm_tag_method_t},
999 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_local_var_t},
1000 {N_("Enums"), TM_ICON_STRUCT, tm_tag_enum_t},
1001 };
1002
1003 static TMParserMapEntry map_CLOJURE[] = {
1004 {'f', tm_tag_function_t}, // function
1005 {'n', tm_tag_namespace_t}, // namespace
1006 };
1007 static TMParserMapGroup group_CLOJURE[] = {
1008 {N_("Namespaces"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
1009 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
1010 };
1011
1012 static TMParserMapEntry map_LISP[] = {
1013 {'Y', tm_tag_undef_t}, // unknown
1014 {'f', tm_tag_function_t}, // function
1015 {'v', tm_tag_variable_t}, // variable
1016 {'m', tm_tag_macro_t}, // macro
1017 {'c', tm_tag_field_t}, // const
1018 };
1019 static TMParserMapGroup group_LISP[] = {
1020 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
1021 {N_("Macros"), TM_ICON_MACRO, tm_tag_macro_t},
1022 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
1023 {N_("Constants"), TM_ICON_VAR, tm_tag_field_t},
1024 };
1025
1026 static TMParserMapEntry map_TYPESCRIPT[] = {
1027 {'f', tm_tag_function_t}, // function
1028 {'c', tm_tag_class_t}, // class
1029 {'i', tm_tag_interface_t}, // interface
1030 {'g', tm_tag_enum_t}, // enum
1031 {'e', tm_tag_enumerator_t}, // enumerator
1032 {'m', tm_tag_method_t}, // method
1033 {'n', tm_tag_namespace_t}, // namespace
1034 {'z', tm_tag_local_var_t}, // parameter
1035 {'p', tm_tag_member_t}, // property
1036 {'v', tm_tag_variable_t}, // variable
1037 {'l', tm_tag_local_var_t}, // local
1038 {'C', tm_tag_macro_t}, // constant
1039 {'G', tm_tag_undef_t}, // generator
1040 {'a', tm_tag_undef_t}, // alias
1041 };
1042 static TMParserMapGroup group_TYPESCRIPT[] = {
1043 {N_("Namespaces"), TM_ICON_NAMESPACE, tm_tag_namespace_t},
1044 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
1045 {N_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t},
1046 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_method_t},
1047 {N_("Enums"), TM_ICON_STRUCT, tm_tag_enum_t},
1048 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t | tm_tag_local_var_t},
1049 {N_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
1050 {N_("Other"), TM_ICON_MEMBER, tm_tag_member_t | tm_tag_enumerator_t},
1051 };
1052
1053 static TMParserMapEntry map_ADA[] = {
1054 {'P', tm_tag_package_t}, // packspec
1055 {'p', tm_tag_package_t}, // package
1056 {'T', tm_tag_typedef_t}, // typespec
1057 {'t', tm_tag_typedef_t}, // type
1058 {'U', tm_tag_undef_t}, // subspec
1059 {'u', tm_tag_typedef_t}, // subtype
1060 {'c', tm_tag_member_t}, // component
1061 {'l', tm_tag_enumerator_t}, // literal
1062 {'V', tm_tag_undef_t}, // varspec
1063 {'v', tm_tag_variable_t}, // variable
1064 {'f', tm_tag_undef_t}, // formal
1065 {'n', tm_tag_macro_t}, // constant
1066 {'x', tm_tag_undef_t}, // exception
1067 {'R', tm_tag_prototype_t}, // subprogspec
1068 {'r', tm_tag_function_t}, // subprogram
1069 {'K', tm_tag_prototype_t}, // taskspec
1070 {'k', tm_tag_method_t}, // task
1071 {'O', tm_tag_undef_t}, // protectspec
1072 {'o', tm_tag_undef_t}, // protected
1073 {'E', tm_tag_undef_t}, // entryspec
1074 {'e', tm_tag_undef_t}, // entry
1075 {'b', tm_tag_undef_t}, // label
1076 {'i', tm_tag_undef_t}, // identifier
1077 {'a', tm_tag_undef_t}, // autovar
1078 {'y', tm_tag_undef_t}, // anon
1079 };
1080 static TMParserMapGroup group_ADA[] = {
1081 {N_("Packages"), TM_ICON_NAMESPACE, tm_tag_package_t},
1082 {N_("Types"), TM_ICON_STRUCT, tm_tag_typedef_t},
1083 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_prototype_t},
1084 {N_("Tasks"), TM_ICON_METHOD, tm_tag_method_t},
1085 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
1086 {N_("Constants"), TM_ICON_MACRO, tm_tag_macro_t},
1087 {N_("Other"), TM_ICON_MEMBER, tm_tag_member_t | tm_tag_enumerator_t},
1088 };
1089
1090 static TMParserMapEntry map_BATCH[] = {
1091 {'l', tm_tag_other_t}, // label
1092 {'v', tm_tag_variable_t}, // variable
1093 };
1094 static TMParserMapGroup group_BATCH[] = {
1095 {N_("Labels"), TM_ICON_OTHER, tm_tag_other_t},
1096 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
1097 };
1098
1099 static TMParserMapEntry map_AUTOIT[] = {
1100 {'f', tm_tag_function_t},
1101 {'r', tm_tag_other_t},
1102 {'g', tm_tag_variable_t},
1103 {'l', tm_tag_variable_t},
1104 {'S', tm_tag_undef_t},
1105 };
1106 static TMParserMapGroup group_AUTOIT[] = {
1107 {N_("Functions"), TM_ICON_METHOD, tm_tag_function_t},
1108 {N_("Regions"), TM_ICON_OTHER, tm_tag_other_t},
1109 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
1110 };
1111
1112 static TMParserMapEntry map_RAKU[] = {
1113 {'c', tm_tag_class_t}, // class
1114 {'g', tm_tag_struct_t}, // grammar
1115 {'m', tm_tag_method_t}, // method
1116 {'o', tm_tag_namespace_t}, // module
1117 {'p', tm_tag_package_t}, // package
1118 {'r', tm_tag_class_t}, // role
1119 {'u', tm_tag_variable_t}, // rule
1120 {'b', tm_tag_method_t}, // submethod
1121 {'s', tm_tag_function_t}, // subroutine
1122 {'t', tm_tag_variable_t}, // token
1123 };
1124 static TMParserMapGroup group_RAKU[] = {
1125 {N_("Packages / Modules"), TM_ICON_NAMESPACE, tm_tag_package_t | tm_tag_namespace_t},
1126 {N_("Classes / Roles"), TM_ICON_CLASS, tm_tag_class_t},
1127 {N_("Grammars"), TM_ICON_STRUCT, tm_tag_struct_t},
1128 {N_("Methods"), TM_ICON_METHOD, tm_tag_method_t},
1129 {N_("Subroutines"), TM_ICON_METHOD, tm_tag_function_t},
1130 {N_("Rules / Tokens"), TM_ICON_VAR, tm_tag_variable_t},
1131 };
1132
1133 static TMParserMapEntry map_OCAML[] = {
1134 {'c', tm_tag_class_t}, // class
1135 {'m', tm_tag_method_t}, // method
1136 {'M', tm_tag_package_t}, // module
1137 {'v', tm_tag_variable_t}, // var
1138 {'p', tm_tag_undef_t}, // val
1139 {'t', tm_tag_typedef_t}, // type
1140 {'f', tm_tag_function_t}, // function
1141 {'C', tm_tag_undef_t}, // Constructor
1142 {'r', tm_tag_undef_t}, // RecordField
1143 {'e', tm_tag_undef_t}, // Exception
1144 };
1145 static TMParserMapGroup group_OCAML[] = {
1146 {N_("Modules"), TM_ICON_NAMESPACE, tm_tag_package_t},
1147 {N_("Classes"), TM_ICON_CLASS, tm_tag_class_t},
1148 {N_("Types"), TM_ICON_STRUCT, tm_tag_typedef_t},
1149 {N_("Functions"), TM_ICON_METHOD, tm_tag_method_t | tm_tag_function_t},
1150 {N_("Variables"), TM_ICON_VAR, tm_tag_variable_t},
1151 };
1152
1153 /* unused by Geany but used by the cxx parser as an external parser so it has to
1154 * be defined */
1155 static TMParserMapEntry map_LDSCRIPT[] = {
1156 {'S', tm_tag_undef_t}, // section
1157 {'s', tm_tag_undef_t}, // symbol
1158 {'v', tm_tag_undef_t}, // version
1159 {'i', tm_tag_undef_t}, // inputSection
1160 };
1161 static TMParserMapGroup group_LDSCRIPT[] = {
1162 };
1163
1164 typedef struct
1165 {
1166 TMParserMapEntry *entries;
1167 guint size;
1168 TMParserMapGroup *groups;
1169 guint group_num;
1170 } TMParserMap;
1171
1172 #define MAP_ENTRY(lang) [TM_PARSER_##lang] = {map_##lang, G_N_ELEMENTS(map_##lang), group_##lang, G_N_ELEMENTS(group_##lang)}
1173
1174 /* keep in sync with TM_PARSER_* definitions in the header */
1175 static TMParserMap parser_map[] = {
1176 MAP_ENTRY(C),
1177 MAP_ENTRY(CPP),
1178 MAP_ENTRY(JAVA),
1179 MAP_ENTRY(MAKEFILE),
1180 MAP_ENTRY(PASCAL),
1181 MAP_ENTRY(PERL),
1182 MAP_ENTRY(PHP),
1183 MAP_ENTRY(PYTHON),
1184 MAP_ENTRY(LATEX),
1185 MAP_ENTRY(BIBTEX),
1186 MAP_ENTRY(ASM),
1187 MAP_ENTRY(CONF),
1188 MAP_ENTRY(SQL),
1189 MAP_ENTRY(DOCBOOK),
1190 MAP_ENTRY(ERLANG),
1191 MAP_ENTRY(CSS),
1192 MAP_ENTRY(RUBY),
1193 MAP_ENTRY(TCL),
1194 MAP_ENTRY(SH),
1195 MAP_ENTRY(D),
1196 MAP_ENTRY(FORTRAN),
1197 MAP_ENTRY(GDSCRIPT),
1198 MAP_ENTRY(DIFF),
1199 MAP_ENTRY(VHDL),
1200 MAP_ENTRY(LUA),
1201 MAP_ENTRY(JAVASCRIPT),
1202 MAP_ENTRY(HASKELL),
1203 MAP_ENTRY(CSHARP),
1204 MAP_ENTRY(FREEBASIC),
1205 MAP_ENTRY(HAXE),
1206 MAP_ENTRY(REST),
1207 MAP_ENTRY(HTML),
1208 MAP_ENTRY(ADA),
1209 MAP_ENTRY(CUDA),
1210 MAP_ENTRY(MATLAB),
1211 MAP_ENTRY(VALA),
1212 MAP_ENTRY(ACTIONSCRIPT),
1213 MAP_ENTRY(NSIS),
1214 MAP_ENTRY(MARKDOWN),
1215 MAP_ENTRY(TXT2TAGS),
1216 MAP_ENTRY(ABC),
1217 MAP_ENTRY(VERILOG),
1218 MAP_ENTRY(R),
1219 MAP_ENTRY(COBOL),
1220 MAP_ENTRY(OBJC),
1221 MAP_ENTRY(ASCIIDOC),
1222 MAP_ENTRY(ABAQUS),
1223 MAP_ENTRY(RUST),
1224 MAP_ENTRY(GO),
1225 MAP_ENTRY(JSON),
1226 MAP_ENTRY(ZEPHIR),
1227 MAP_ENTRY(POWERSHELL),
1228 MAP_ENTRY(JULIA),
1229 MAP_ENTRY(CPREPROCESSOR),
1230 MAP_ENTRY(TCLOO),
1231 MAP_ENTRY(CLOJURE),
1232 MAP_ENTRY(LISP),
1233 MAP_ENTRY(TYPESCRIPT),
1234 MAP_ENTRY(BATCH),
1235 MAP_ENTRY(AUTOIT),
1236 MAP_ENTRY(RAKU),
1237 MAP_ENTRY(OCAML),
1238 MAP_ENTRY(LDSCRIPT),
1239 };
1240 /* make sure the parser map is consistent and complete */
1241 G_STATIC_ASSERT(G_N_ELEMENTS(parser_map) == TM_PARSER_COUNT);
1242
1243
1244 TMTagType tm_parser_get_tag_type(gchar kind, TMParserType lang)
1245 {
1246 TMParserMap *map = &parser_map[lang];
1247 guint i;
1248
1249 for (i = 0; i < map->size; i++)
1250 {
1251 TMParserMapEntry *entry = &map->entries[i];
1252
1253 if (entry->kind == kind)
1254 return entry->type;
1255 }
1256 return tm_tag_undef_t;
1257 }
1258
1259
1260 gchar tm_parser_get_tag_kind(TMTagType type, TMParserType lang)
1261 {
1262 TMParserMap *map = &parser_map[lang];
1263 guint i;
1264
1265 for (i = 0; i < map->size; i++)
1266 {
1267 TMParserMapEntry *entry = &map->entries[i];
1268
1269 if (entry->type == type)
1270 return entry->kind;
1271 }
1272 return '\0';
1273 }
1274
1275
1276 gint tm_parser_get_sidebar_group(TMParserType lang, TMTagType type)
1277 {
1278 TMParserMap *map;
1279 guint i;
1280
1281 if (lang >= TM_PARSER_COUNT)
1282 return -1;
1283
1284 map = &parser_map[lang];
1285 for (i = 0; i < map->group_num; i++)
1286 {
1287 if (map->groups[i].types & type)
1288 return i + 1; // "Symbols" group is always first
1289 }
1290 return -1;
1291 }
1292
1293
1294 const gchar *tm_parser_get_sidebar_info(TMParserType lang, gint group, guint *icon)
1295 {
1296 const gchar *name;
1297 TMParserMap *map;
1298 TMParserMapGroup *grp;
1299
1300 if (lang >= TM_PARSER_COUNT)
1301 return NULL;
1302
1303 if (group == 0)
1304 {
1305 name = _("Symbols");
1306 *icon = TM_ICON_NAMESPACE;
1307 }
1308 else
1309 {
1310 map = &parser_map[lang];
1311 if (group > (gint)map->group_num)
1312 return NULL;
1313
1314 grp = &map->groups[group - 1];
1315 name = _(grp->name);
1316 *icon = grp->icon;
1317 }
1318
1319 return name;
1320 }
1321
1322
1323 static void add_subparser(TMParserType lang, TMParserType sublang, TMSubparserMapEntry *map, guint map_size)
1324 {
1325 guint i;
1326 GPtrArray *mapping;
1327 GHashTable *lang_map = g_hash_table_lookup(subparser_map, GINT_TO_POINTER(lang));
1328
1329 if (!lang_map)
1330 {
1331 lang_map = g_hash_table_new(g_direct_hash, g_direct_equal);
1332 g_hash_table_insert(subparser_map, GINT_TO_POINTER(lang), lang_map);
1333 }
1334
1335 mapping = g_ptr_array_new();
1336 for (i = 0; i < map_size; i++)
1337 g_ptr_array_add(mapping, &map[i]);
1338
1339 g_hash_table_insert(lang_map, GINT_TO_POINTER(sublang), mapping);
1340 }
1341
1342
1343 #define SUBPARSER_MAP_ENTRY(lang, sublang, map) add_subparser(TM_PARSER_##lang, TM_PARSER_##sublang, map, G_N_ELEMENTS(map))
1344
1345 static void init_subparser_map(void)
1346 {
1347 SUBPARSER_MAP_ENTRY(HTML, JAVASCRIPT, subparser_HTML_javascript_map);
1348 SUBPARSER_MAP_ENTRY(TCLOO, TCL, subparser_TCLOO_TCL_map);
1349 }
1350
1351
1352 TMTagType tm_parser_get_subparser_type(TMParserType lang, TMParserType sublang, TMTagType type)
1353 {
1354 guint i;
1355 GHashTable *lang_map;
1356 GPtrArray *mapping;
1357
1358 if (!subparser_map)
1359 {
1360 subparser_map = g_hash_table_new(g_direct_hash, g_direct_equal);
1361 init_subparser_map();
1362 }
1363
1364 lang_map = g_hash_table_lookup(subparser_map, GINT_TO_POINTER(lang));
1365 if (!lang_map)
1366 return tm_tag_undef_t;
1367
1368 mapping = g_hash_table_lookup(lang_map, GINT_TO_POINTER(sublang));
1369 if (!mapping)
1370 return tm_tag_undef_t;
1371
1372 for (i = 0; i < mapping->len; i++)
1373 {
1374 TMSubparserMapEntry *entry = mapping->pdata[i];
1375 if (entry->orig_type == type)
1376 return entry->new_type;
1377 }
1378
1379 return tm_tag_undef_t;
1380 }
1381
1382
1383 void tm_parser_verify_type_mappings(void)
1384 {
1385 TMParserType lang;
1386
1387 if (TM_PARSER_COUNT > tm_ctags_get_lang_count())
1388 g_error("More parsers defined in Geany than in ctags");
1389
1390 for (lang = 0; lang < TM_PARSER_COUNT; lang++)
1391 {
1392 const gchar *kinds = tm_ctags_get_lang_kinds(lang);
1393 TMParserMap *map = &parser_map[lang];
1394 gchar presence_map[256];
1395 TMTagType lang_types = 0;
1396 TMTagType group_types = 0;
1397 guint i;
1398
1399 if (! map->entries || map->size < 1)
1400 g_error("No tag types in TM for %s, is the language listed in parser_map?",
1401 tm_ctags_get_lang_name(lang));
1402
1403 if (map->size != strlen(kinds))
1404 g_error("Different number of tag types in TM (%d) and ctags (%d) for %s",
1405 map->size, (int)strlen(kinds), tm_ctags_get_lang_name(lang));
1406
1407 memset(presence_map, 0, sizeof(presence_map));
1408 for (i = 0; i < map->size; i++)
1409 {
1410 gboolean ctags_found = FALSE;
1411 gboolean tm_found = FALSE;
1412 guint j;
1413
1414 for (j = 0; j < map->size; j++)
1415 {
1416 /* check that for every type in TM there's a type in ctags */
1417 if (map->entries[i].kind == kinds[j])
1418 ctags_found = TRUE;
1419 /* check that for every type in ctags there's a type in TM */
1420 if (map->entries[j].kind == kinds[i])
1421 tm_found = TRUE;
1422 if (ctags_found && tm_found)
1423 break;
1424 }
1425 if (!ctags_found)
1426 g_error("Tag type '%c' found in TM but not in ctags for %s",
1427 map->entries[i].kind, tm_ctags_get_lang_name(lang));
1428 if (!tm_found)
1429 g_error("Tag type '%c' found in ctags but not in TM for %s",
1430 kinds[i], tm_ctags_get_lang_name(lang));
1431
1432 presence_map[(unsigned char) map->entries[i].kind]++;
1433 lang_types |= map->entries[i].type;
1434 }
1435
1436 for (i = 0; i < sizeof(presence_map); i++)
1437 {
1438 if (presence_map[i] > 1)
1439 g_error("Duplicate tag type '%c' found for %s",
1440 (gchar)i, tm_ctags_get_lang_name(lang));
1441 }
1442
1443 for (i = 0; i < map->group_num; i++)
1444 group_types |= map->groups[i].types;
1445
1446 if ((group_types & lang_types) != lang_types)
1447 g_warning("Not all tag types mapped to symbol tree groups for %s",
1448 tm_ctags_get_lang_name(lang));
1449 }
1450 }
1451
1452
1453 /* When the suffix of 'str' is an operator that should trigger scope
1454 * autocompletion, this function should return the length of the operator,
1455 * zero otherwise. */
1456 gint tm_parser_scope_autocomplete_suffix(TMParserType lang, const gchar *str)
1457 {
1458 const gchar *sep = tm_parser_scope_separator(lang);
1459
1460 if (g_str_has_suffix(str, sep))
1461 return strlen(sep);
1462
1463 switch (lang)
1464 {
1465 case TM_PARSER_C:
1466 case TM_PARSER_CPP:
1467 if (g_str_has_suffix(str, "."))
1468 return 1;
1469 else if (g_str_has_suffix(str, "->"))
1470 return 2;
1471 else if (lang == TM_PARSER_CPP && g_str_has_suffix(str, "->*"))
1472 return 3;
1473 default:
1474 break;
1475 }
1476 return 0;
1477 }
1478
1479
1480 /* Get the name of constructor method. Arguments of this method will be used
1481 * for calltips when creating an object using the class name
1482 * (e.g. after the opening brace in 'c = MyClass()' in Python) */
1483 const gchar *tm_parser_get_constructor_method(TMParserType lang)
1484 {
1485 switch (lang)
1486 {
1487 case TM_PARSER_D:
1488 return "this";
1489 case TM_PARSER_PYTHON:
1490 return "__init__";
1491 default:
1492 return NULL;
1493 }
1494 }
1495
1496
1497 /* determine anonymous tags from tag names only when corresponding
1498 * ctags information is not available */
1499 gboolean tm_parser_is_anon_name(TMParserType lang, const gchar *name)
1500 {
1501 guint i;
1502 char dummy;
1503
1504 if (sscanf(name, "__anon%u%c", &i, &dummy) == 1) /* uctags tags files */
1505 return TRUE;
1506 else if (lang == TM_PARSER_C || lang == TM_PARSER_CPP) /* legacy Geany tags files */
1507 return sscanf(name, "anon_%*[a-z]_%u%c", &i, &dummy) == 1;
1508 else if (lang == TM_PARSER_FORTRAN) /* legacy Geany tags files */
1509 {
1510 return sscanf(name, "Structure#%u%c", &i, &dummy) == 1 ||
1511 sscanf(name, "Interface#%u%c", &i, &dummy) == 1 ||
1512 sscanf(name, "Enum#%u%c", &i, &dummy) == 1;
1513 }
1514 return FALSE;
1515 }
1516
1517
1518 static gchar *replace_string_if_present(gchar *haystack, const gchar *needle, const gchar *subst)
1519 {
1520 if (strstr(haystack, needle))
1521 {
1522 gchar **split = g_strsplit(haystack, needle, -1);
1523 gchar *ret = g_strjoinv(subst, split);
1524 g_strfreev(split);
1525 return ret;
1526 }
1527 return haystack;
1528 }
1529
1530
1531 /* return updated scope or original scope if no change needed */
1532 gchar *tm_parser_update_scope(TMParserType lang, gchar *scope)
1533 {
1534 switch (lang)
1535 {
1536 case TM_PARSER_PHP:
1537 case TM_PARSER_ZEPHIR:
1538 /* PHP parser uses two different scope separators but this would
1539 * complicate things in Geany so make sure there's just one type */
1540 return replace_string_if_present(scope, "\\", "::");
1541 case TM_PARSER_TCL:
1542 case TM_PARSER_TCLOO:
1543 /* The TCL(OO) parser returns scope prefixed with :: which we don't
1544 * want. */
1545 if (g_str_has_prefix(scope, "::"))
1546 return g_strdup(scope + 2);
1547 break;
1548 }
1549 return scope;
1550 }
1551
1552
1553 /* whether or not to enable ctags roles for the given language and kind */
1554 gboolean tm_parser_enable_role(TMParserType lang, gchar kind)
1555 {
1556 switch (lang)
1557 {
1558 case TM_PARSER_GDSCRIPT:
1559 return kind == 'c' ? FALSE : TRUE;
1560 case TM_PARSER_GO:
1561 /* 'p' is used both for package definition tags and imported package
1562 * tags and we can't tell which is which just by kind. By disabling
1563 * roles for this kind, we only get package definition tags. */
1564 return kind == 'p' ? FALSE : TRUE;
1565 }
1566 return TRUE;
1567 }
1568
1569
1570 /* whether or not to enable ctags kinds for the given language */
1571 gboolean tm_parser_enable_kind(TMParserType lang, gchar kind)
1572 {
1573 TMParserMap *map;
1574 guint i;
1575
1576 if (lang >= TM_PARSER_COUNT)
1577 /* Fatal error but tm_parser_verify_type_mappings() will provide
1578 * better message later */
1579 return FALSE;
1580
1581 map = &parser_map[lang];
1582 for (i = 0; i < map->size; i++)
1583 {
1584 if (map->entries[i].kind == kind)
1585 return map->entries[i].type != tm_tag_undef_t;
1586 }
1587 return FALSE;
1588 }
1589
1590
1591 gchar *tm_parser_format_variable(TMParserType lang, const gchar *name, const gchar *type,
1592 const gchar *scope)
1593 {
1594 gchar *ret, *name_full;
1595
1596 if (!type)
1597 return NULL;
1598
1599 if (scope)
1600 name_full = g_strconcat(scope, tm_parser_scope_separator_printable(lang),
1601 name, NULL);
1602 else
1603 name_full = g_strdup(name);
1604
1605 switch (lang)
1606 {
1607 case TM_PARSER_GO:
1608 ret = g_strconcat(name_full, " ", type, NULL);
1609 break;
1610 case TM_PARSER_PASCAL:
1611 case TM_PARSER_PYTHON:
1612 ret = g_strconcat(name_full, ": ", type, NULL);
1613 break;
1614 default:
1615 ret = g_strconcat(type, " ", name_full, NULL);
1616 break;
1617 }
1618
1619 g_free(name_full);
1620 return ret;
1621 }
1622
1623
1624 gchar *tm_parser_format_function(TMParserType lang, const gchar *fname, const gchar *args,
1625 const gchar *retval, const gchar *scope)
1626 {
1627 GString *str;
1628
1629 if (!args) /* not a function */
1630 return NULL;
1631
1632 str = g_string_new(NULL);
1633
1634 if (scope)
1635 {
1636 g_string_append(str, scope);
1637 g_string_append(str, tm_parser_scope_separator_printable(lang));
1638 }
1639 g_string_append(str, fname);
1640 g_string_append_c(str, ' ');
1641 g_string_append(str, args);
1642
1643 if (retval)
1644 {
1645 const gchar *sep = NULL;
1646
1647 switch (lang)
1648 {
1649 /* retval after function */
1650 case TM_PARSER_PASCAL:
1651 sep = ": ";
1652 break;
1653 case TM_PARSER_GDSCRIPT:
1654 case TM_PARSER_PYTHON:
1655 sep = " -> ";
1656 break;
1657 case TM_PARSER_GO:
1658 sep = " ";
1659 break;
1660 default:
1661 break;
1662 }
1663
1664 if (sep)
1665 {
1666 /* retval after function */
1667 g_string_append(str, sep);
1668 g_string_append(str, retval);
1669 }
1670 else
1671 {
1672 /* retval before function */
1673 g_string_prepend_c(str, ' ');
1674 g_string_prepend(str, retval);
1675 }
1676 }
1677
1678 return g_string_free(str, FALSE);
1679 }
1680
1681
1682 const gchar *tm_parser_scope_separator(TMParserType lang)
1683 {
1684 switch (lang)
1685 {
1686 case TM_PARSER_C: /* for C++ .h headers or C structs */
1687 case TM_PARSER_CPP:
1688 case TM_PARSER_CUDA:
1689 case TM_PARSER_PHP:
1690 case TM_PARSER_POWERSHELL:
1691 case TM_PARSER_RUST:
1692 case TM_PARSER_TCL:
1693 case TM_PARSER_TCLOO:
1694 case TM_PARSER_ZEPHIR:
1695 return "::";
1696
1697 case TM_PARSER_LATEX:
1698 case TM_PARSER_MARKDOWN:
1699 case TM_PARSER_TXT2TAGS:
1700 return "\"\"";
1701
1702 /* these parsers don't report nested scopes but default "." for scope separator
1703 * might appear in the text so use something more improbable */
1704 case TM_PARSER_ASCIIDOC:
1705 case TM_PARSER_CONF:
1706 case TM_PARSER_REST:
1707 return "\x3";
1708
1709 default:
1710 return ".";
1711 }
1712 }
1713
1714
1715 const gchar *tm_parser_scope_separator_printable(TMParserType lang)
1716 {
1717 switch (lang)
1718 {
1719 case TM_PARSER_ASCIIDOC:
1720 case TM_PARSER_CONF:
1721 case TM_PARSER_LATEX:
1722 case TM_PARSER_MARKDOWN:
1723 case TM_PARSER_REST:
1724 case TM_PARSER_TXT2TAGS:
1725 return " > ";
1726
1727 default:
1728 return tm_parser_scope_separator(lang);
1729 }
1730 }
1731
1732
1733 gboolean tm_parser_has_full_scope(TMParserType lang)
1734 {
1735 switch (lang)
1736 {
1737 /* These parsers include full hierarchy in the tag scope, separated by tm_parser_scope_separator() */
1738 case TM_PARSER_ACTIONSCRIPT:
1739 case TM_PARSER_C:
1740 case TM_PARSER_CPP:
1741 case TM_PARSER_CUDA:
1742 case TM_PARSER_CSHARP:
1743 case TM_PARSER_COBOL:
1744 case TM_PARSER_D:
1745 case TM_PARSER_GDSCRIPT:
1746 case TM_PARSER_GO:
1747 case TM_PARSER_JAVA:
1748 case TM_PARSER_JAVASCRIPT:
1749 case TM_PARSER_JSON:
1750 case TM_PARSER_LATEX:
1751 case TM_PARSER_LUA:
1752 case TM_PARSER_MARKDOWN:
1753 case TM_PARSER_PHP:
1754 case TM_PARSER_POWERSHELL:
1755 case TM_PARSER_PYTHON:
1756 case TM_PARSER_R:
1757 case TM_PARSER_RUBY:
1758 case TM_PARSER_RUST:
1759 case TM_PARSER_SQL:
1760 case TM_PARSER_TCL:
1761 case TM_PARSER_TCLOO:
1762 case TM_PARSER_TXT2TAGS:
1763 case TM_PARSER_TYPESCRIPT:
1764 case TM_PARSER_VALA:
1765 case TM_PARSER_VHDL:
1766 case TM_PARSER_VERILOG:
1767 case TM_PARSER_ZEPHIR:
1768 case TM_PARSER_AUTOIT:
1769 return TRUE;
1770
1771 /* These make use of the scope, but don't include nested hierarchy
1772 * (either as a parser limitation or a language semantic) */
1773 case TM_PARSER_ADA:
1774 case TM_PARSER_ASCIIDOC:
1775 case TM_PARSER_CLOJURE:
1776 case TM_PARSER_CONF:
1777 case TM_PARSER_ERLANG:
1778 case TM_PARSER_FORTRAN:
1779 case TM_PARSER_OBJC:
1780 case TM_PARSER_OCAML:
1781 case TM_PARSER_REST:
1782 /* Other parsers don't use scope at all (or should be somewhere above) */
1783 default:
1784 return FALSE;
1785 }
1786 }
1787
1788
1789 gboolean tm_parser_langs_compatible(TMParserType lang, TMParserType other)
1790 {
1791 if (lang == TM_PARSER_NONE || other == TM_PARSER_NONE)
1792 return FALSE;
1793 if (lang == other)
1794 return TRUE;
1795 /* Accept CPP tags for C lang and vice versa */
1796 else if (lang == TM_PARSER_C && other == TM_PARSER_CPP)
1797 return TRUE;
1798 else if (lang == TM_PARSER_CPP && other == TM_PARSER_C)
1799 return TRUE;
1800
1801 return FALSE;
1802 }
A fast and lightweight IDE