src/tagmanager/tm_ctags_wrappers.c

   1 /*
   2  *      tm_ctags_wrappers.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2016 Jiri Techet <techet(at)gmail(dot)com>
   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_ctags_wrappers.h"
  22
  23 #include "general.h"
  24 #include "entry.h"
  25 #include "parse.h"
  26 #include "read.h"
  27
  28
  29 typedef struct {
  30         TMCtagsNewTagCallback tag_callback;
  31         gpointer user_data;
  32 } CallbackUserData;
  33
  34
  35 void tm_ctags_init(void)
  36 {
  37         initializeParsing();
  38         installLanguageMapDefaults();
  39 }
  40
  41
  42 static gboolean parse_callback(const tagEntryInfo *tag, gpointer user_data)
  43 {
  44         CallbackUserData *callback_data = user_data;
  45
  46         return callback_data->tag_callback(tag, callback_data->user_data);
  47 }
  48
  49
  50 void tm_ctags_parse(guchar *buffer, gsize buffer_size,
  51         const gchar *file_name, TMParserType lang, TMCtagsNewTagCallback tag_callback,
  52         TMCtagsPassStartCallback pass_callback, gpointer user_data)
  53 {
  54         CallbackUserData callback_data = {tag_callback, user_data};
  55         gboolean retry = TRUE;
  56         guint passCount = 0;
  57
  58         g_return_if_fail(buffer || file_name);
  59
  60         if (! LanguageTable [lang]->enabled)
  61         {
  62 #ifdef TM_DEBUG
  63                 g_warning("ignoring %s (language disabled)\n", file_name);
  64 #endif
  65                 return;
  66         }
  67
  68         setTagEntryFunction(parse_callback, &callback_data);
  69         while (retry && passCount < 3)
  70         {
  71                 pass_callback(user_data);
  72                 if (!buffer && fileOpen (file_name, lang))
  73                 {
  74                         if (LanguageTable [lang]->parser != NULL)
  75                         {
  76                                 LanguageTable [lang]->parser ();
  77                                 fileClose ();
  78                                 retry = FALSE;
  79                                 break;
  80                         }
  81                         else if (LanguageTable [lang]->parser2 != NULL)
  82                                 retry = LanguageTable [lang]->parser2 (passCount);
  83                         fileClose ();
  84                 }
  85                 else if (buffer && bufferOpen (buffer, buffer_size, file_name, lang))
  86                 {
  87                         if (LanguageTable [lang]->parser != NULL)
  88                         {
  89                                 LanguageTable [lang]->parser ();
  90                                 bufferClose ();
  91                                 retry = FALSE;
  92                                 break;
  93                         }
  94                         else if (LanguageTable [lang]->parser2 != NULL)
  95                                 retry = LanguageTable [lang]->parser2 (passCount);
  96                         bufferClose ();
  97                 }
  98                 else
  99                 {
 100                         g_warning("Unable to open %s", file_name);
 101                         return;
 102                 }
 103                 ++ passCount;
 104         }
 105 }
 106
 107
 108 const gchar *tm_ctags_get_lang_name(TMParserType lang)
 109 {
 110         return getLanguageName(lang);
 111 }
 112
 113
 114 TMParserType tm_ctags_get_named_lang(const gchar *name)
 115 {
 116         return getNamedLanguage(name);
 117 }
 118
 119
 120 const gchar *tm_ctags_get_lang_kinds(TMParserType lang)
 121 {
 122         guint i;
 123         parserDefinition *def = LanguageTable[lang];
 124         static gchar kinds[257];
 125
 126         for (i = 0; i < def->kindCount; i++)
 127                 kinds[i] = def->kinds[i].letter;
 128         kinds[i] = '\0';
 129
 130         return kinds;
 131 }
 132
 133
 134 const gchar *tm_ctags_get_kind_name(gchar kind, TMParserType lang)
 135 {
 136         guint i;
 137         parserDefinition *def = LanguageTable[lang];
 138
 139         for (i = 0; i < def->kindCount; i++)
 140         {
 141                 if (def->kinds[i].letter == kind)
 142                         return def->kinds[i].name;
 143         }
 144         return "unknown";
 145 }
 146
 147
 148 gchar tm_ctags_get_kind_from_name(const gchar *name, TMParserType lang)
 149 {
 150         guint i;
 151         parserDefinition *def = LanguageTable[lang];
 152
 153         for (i = 0; i < def->kindCount; i++)
 154         {
 155                 if (g_strcmp0(def->kinds[i].name, name) == 0)
 156                         return def->kinds[i].letter;
 157         }
 158         return '-';
 159 }
 160
 161
 162 gboolean tm_ctags_is_using_regex_parser(TMParserType lang)
 163 {
 164         return LanguageTable[lang]->method & METHOD_REGEX;
 165 }
 166
 167
 168 guint tm_ctags_get_lang_count(void)
 169 {
 170         return LanguageCount;
 171 }